diff --git a/docs/node/BrowserWebSocketTransport-VT34BAS5.mjs b/docs/node/BrowserWebSocketTransport-VT34BAS5.mjs new file mode 100644 index 00000000..394cdae3 --- /dev/null +++ b/docs/node/BrowserWebSocketTransport-VT34BAS5.mjs @@ -0,0 +1,8 @@ +import { createRequire } from 'module';const require = createRequire(import.meta.url); +import { + BrowserWebSocketTransport +} from "./chunk-CTKBT5JH.mjs"; +import "./chunk-THMF2HPO.mjs"; +export { + BrowserWebSocketTransport +}; diff --git a/docs/node/NodeWebSocketTransport-UA4FKYLF.mjs b/docs/node/NodeWebSocketTransport-UA4FKYLF.mjs new file mode 100644 index 00000000..04b4fb8c --- /dev/null +++ b/docs/node/NodeWebSocketTransport-UA4FKYLF.mjs @@ -0,0 +1,9 @@ +import { createRequire } from 'module';const require = createRequire(import.meta.url); +import { + NodeWebSocketTransport +} from "./chunk-PJC2V65J.mjs"; +import "./chunk-VDOS7AVZ.mjs"; +import "./chunk-THMF2HPO.mjs"; +export { + NodeWebSocketTransport +}; diff --git a/docs/node/bidi-2I2CA3WT.mjs b/docs/node/bidi-2I2CA3WT.mjs new file mode 100644 index 00000000..1d3d11de --- /dev/null +++ b/docs/node/bidi-2I2CA3WT.mjs @@ -0,0 +1,16586 @@ +import { createRequire } from 'module';const require = createRequire(import.meta.url); +import { + ARIAQueryHandler, + Accessibility, + AsyncIterableUtil, + Browser, + BrowserContext, + CDPSession, + CallbackRegistry, + ConsoleMessage, + Coverage, + Deferred, + Dialog, + DisposableStack, + ElementHandle, + EmulationManager, + EventEmitter, + Frame, + HTTPRequest, + HTTPResponse, + JSHandle, + Keyboard, + LazyArg, + Mouse, + MouseButton, + Page, + ProtocolError, + PuppeteerURL, + Realm, + SOURCE_URL_REGEX, + STATUS_TEXTS, + SecurityDetails, + Target, + TargetCloseError, + TargetType, + TimeoutError, + TouchError, + Touchscreen, + Tracing, + UnsupportedOperation, + WEB_PERMISSION_TO_PROTOCOL_PERMISSION, + WebWorker, + assert, + bindIsolatedHandle, + bubble, + combineLatest, + debug, + debugError, + defer, + delayWhen, + disposeSymbol, + environment, + evaluationString, + filter, + first, + firstValueFrom, + from, + fromAbortSignal, + fromEmitterEvent, + getSourcePuppeteerURLIfAvailable, + getSourceUrlComment, + handleError, + inertIfDisposed, + interpolateFunction, + invokeAtMostOnceForArguments, + isDate, + isErrorLike, + isPlainObject, + isRegExp, + isString, + map, + of, + parsePDFOptions, + raceWith, + scriptInjector, + stringToBase64, + stringToTypedArray, + stringifyFunction, + switchMap, + throwIfDetached, + throwIfDisposed, + timeout +} from "./chunk-RBWPBMY4.mjs"; +import "./chunk-VDOS7AVZ.mjs"; +import { + __commonJS, + __esm, + __export, + __privateAdd, + __privateGet, + __privateMethod, + __privateSet, + __privateWrapper, + __publicField, + __require, + __toCommonJS, + __toESM, + init_cjs_shim +} from "./chunk-THMF2HPO.mjs"; + +// ../testeranto/node_modules/mitt/dist/mitt.mjs +var mitt_exports = {}; +__export(mitt_exports, { + default: () => mitt_default +}); +function mitt_default(n) { + return { all: n = n || /* @__PURE__ */ new Map(), on: function(t, e) { + var i = n.get(t); + i ? i.push(e) : n.set(t, [e]); + }, off: function(t, e) { + var i = n.get(t); + i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, [])); + }, emit: function(t, e) { + var i = n.get(t); + i && i.slice().map(function(n2) { + n2(e); + }), (i = n.get("*")) && i.slice().map(function(n2) { + n2(t, e); + }); + } }; +} +var init_mitt = __esm({ + "../testeranto/node_modules/mitt/dist/mitt.mjs"() { + init_cjs_shim(); + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/EventEmitter.js +var require_EventEmitter = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/EventEmitter.js"(exports) { + "use strict"; + init_cjs_shim(); + var __importDefault = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.EventEmitter = void 0; + var mitt_1 = __importDefault((init_mitt(), __toCommonJS(mitt_exports))); + var EventEmitter3 = class { + #emitter = (0, mitt_1.default)(); + on(type, handler) { + this.#emitter.on(type, handler); + return this; + } + /** + * Like `on` but the listener will only be fired once and then it will be removed. + * @param event The event you'd like to listen to + * @param handler The handler function to run when the event occurs + * @return `this` to enable chaining method calls. + */ + once(event, handler) { + const onceHandler = (eventData) => { + handler(eventData); + this.off(event, onceHandler); + }; + return this.on(event, onceHandler); + } + off(type, handler) { + this.#emitter.off(type, handler); + return this; + } + /** + * Emits an event and call any associated listeners. + * + * @param event The event to emit. + * @param eventData Any data to emit with the event. + * @return `true` if there are any listeners, `false` otherwise. + */ + emit(event, eventData) { + this.#emitter.emit(event, eventData); + } + /** + * Removes all listeners. If given an event argument, it will remove only + * listeners for that event. + * @param event - the event to remove listeners for. + * @returns `this` to enable you to chain method calls. + */ + removeAllListeners(event) { + if (event) { + this.#emitter.all.delete(event); + } else { + this.#emitter.all.clear(); + } + return this; + } + }; + exports.EventEmitter = EventEmitter3; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/log.js +var require_log = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/log.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.LogType = void 0; + var LogType; + (function(LogType2) { + LogType2["bidi"] = "bidi"; + LogType2["cdp"] = "cdp"; + LogType2["debug"] = "debug"; + LogType2["debugError"] = "debug:error"; + LogType2["debugInfo"] = "debug:info"; + })(LogType || (exports.LogType = LogType = {})); + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/ProcessingQueue.js +var require_ProcessingQueue = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/ProcessingQueue.js"(exports) { + "use strict"; + init_cjs_shim(); + var _a3; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProcessingQueue = void 0; + var log_js_1 = require_log(); + var _logger, _processor, _queue, _isProcessing, _processIfNeeded, processIfNeeded_fn; + var ProcessingQueue = class { + constructor(processor, logger) { + __privateAdd(this, _processIfNeeded); + __privateAdd(this, _logger, void 0); + __privateAdd(this, _processor, void 0); + __privateAdd(this, _queue, []); + // Flag to keep only 1 active processor. + __privateAdd(this, _isProcessing, false); + __privateSet(this, _processor, processor); + __privateSet(this, _logger, logger); + } + add(entry, name) { + __privateGet(this, _queue).push([entry, name]); + void __privateMethod(this, _processIfNeeded, processIfNeeded_fn).call(this); + } + }; + _logger = new WeakMap(); + _processor = new WeakMap(); + _queue = new WeakMap(); + _isProcessing = new WeakMap(); + _processIfNeeded = new WeakSet(); + processIfNeeded_fn = async function() { + var _a4; + if (__privateGet(this, _isProcessing)) { + return; + } + __privateSet(this, _isProcessing, true); + while (__privateGet(this, _queue).length > 0) { + const arrayEntry = __privateGet(this, _queue).shift(); + if (!arrayEntry) { + continue; + } + const [entryPromise, name] = arrayEntry; + (_a4 = __privateGet(this, _logger)) == null ? void 0 : _a4.call(this, _a3.LOGGER_PREFIX, "Processing event:", name); + await entryPromise.then((entry) => { + var _a5; + if (entry.kind === "error") { + (_a5 = __privateGet(this, _logger)) == null ? void 0 : _a5.call(this, log_js_1.LogType.debugError, "Event threw before sending:", entry.error.message, entry.error.stack); + return; + } + return __privateGet(this, _processor).call(this, entry.value); + }).catch((error) => { + var _a5; + (_a5 = __privateGet(this, _logger)) == null ? void 0 : _a5.call(this, log_js_1.LogType.debugError, "Event was not processed:", error?.message); + }); + } + __privateSet(this, _isProcessing, false); + }; + __publicField(ProcessingQueue, "LOGGER_PREFIX", `${log_js_1.LogType.debug}:queue`); + exports.ProcessingQueue = ProcessingQueue; + _a3 = ProcessingQueue; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/cdp.js +var require_cdp = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/cdp.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/chromium-bidi.js +var require_chromium_bidi = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/chromium-bidi.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.EVENT_NAMES = exports.Bluetooth = exports.Network = exports.BrowsingContext = exports.Log = exports.Script = exports.BiDiModule = void 0; + var BiDiModule; + (function(BiDiModule2) { + BiDiModule2["Bluetooth"] = "bluetooth"; + BiDiModule2["Browser"] = "browser"; + BiDiModule2["BrowsingContext"] = "browsingContext"; + BiDiModule2["Cdp"] = "cdp"; + BiDiModule2["Input"] = "input"; + BiDiModule2["Log"] = "log"; + BiDiModule2["Network"] = "network"; + BiDiModule2["Script"] = "script"; + BiDiModule2["Session"] = "session"; + })(BiDiModule || (exports.BiDiModule = BiDiModule = {})); + var Script; + (function(Script2) { + let EventNames; + (function(EventNames2) { + EventNames2["Message"] = "script.message"; + EventNames2["RealmCreated"] = "script.realmCreated"; + EventNames2["RealmDestroyed"] = "script.realmDestroyed"; + })(EventNames = Script2.EventNames || (Script2.EventNames = {})); + })(Script || (exports.Script = Script = {})); + var Log; + (function(Log2) { + let EventNames; + (function(EventNames2) { + EventNames2["LogEntryAdded"] = "log.entryAdded"; + })(EventNames = Log2.EventNames || (Log2.EventNames = {})); + })(Log || (exports.Log = Log = {})); + var BrowsingContext2; + (function(BrowsingContext3) { + let EventNames; + (function(EventNames2) { + EventNames2["ContextCreated"] = "browsingContext.contextCreated"; + EventNames2["ContextDestroyed"] = "browsingContext.contextDestroyed"; + EventNames2["DomContentLoaded"] = "browsingContext.domContentLoaded"; + EventNames2["DownloadWillBegin"] = "browsingContext.downloadWillBegin"; + EventNames2["FragmentNavigated"] = "browsingContext.fragmentNavigated"; + EventNames2["Load"] = "browsingContext.load"; + EventNames2["NavigationAborted"] = "browsingContext.navigationAborted"; + EventNames2["NavigationFailed"] = "browsingContext.navigationFailed"; + EventNames2["NavigationStarted"] = "browsingContext.navigationStarted"; + EventNames2["UserPromptClosed"] = "browsingContext.userPromptClosed"; + EventNames2["UserPromptOpened"] = "browsingContext.userPromptOpened"; + })(EventNames = BrowsingContext3.EventNames || (BrowsingContext3.EventNames = {})); + })(BrowsingContext2 || (exports.BrowsingContext = BrowsingContext2 = {})); + var Network; + (function(Network2) { + let EventNames; + (function(EventNames2) { + EventNames2["AuthRequired"] = "network.authRequired"; + EventNames2["BeforeRequestSent"] = "network.beforeRequestSent"; + EventNames2["FetchError"] = "network.fetchError"; + EventNames2["ResponseCompleted"] = "network.responseCompleted"; + EventNames2["ResponseStarted"] = "network.responseStarted"; + })(EventNames = Network2.EventNames || (Network2.EventNames = {})); + })(Network || (exports.Network = Network = {})); + var Bluetooth; + (function(Bluetooth2) { + let EventNames; + (function(EventNames2) { + EventNames2["RequestDevicePromptUpdated"] = "bluetooth.requestDevicePromptUpdated"; + })(EventNames = Bluetooth2.EventNames || (Bluetooth2.EventNames = {})); + })(Bluetooth || (exports.Bluetooth = Bluetooth = {})); + exports.EVENT_NAMES = /* @__PURE__ */ new Set([ + // keep-sorted start + ...Object.values(BiDiModule), + ...Object.values(BrowsingContext2.EventNames), + ...Object.values(Log.EventNames), + ...Object.values(Network.EventNames), + ...Object.values(Script.EventNames) + // keep-sorted end + ]); + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/generated/webdriver-bidi.js +var require_webdriver_bidi = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/generated/webdriver-bidi.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/ErrorResponse.js +var require_ErrorResponse = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/ErrorResponse.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.UnderspecifiedStoragePartitionException = exports.UnableToSetFileInputException = exports.UnableToSetCookieException = exports.NoSuchStoragePartitionException = exports.UnsupportedOperationException = exports.UnableToCloseBrowserException = exports.UnableToCaptureScreenException = exports.UnknownErrorException = exports.UnknownCommandException = exports.SessionNotCreatedException = exports.NoSuchUserContextException = exports.NoSuchScriptException = exports.NoSuchRequestException = exports.NoSuchNodeException = exports.NoSuchInterceptException = exports.NoSuchHistoryEntryException = exports.NoSuchHandleException = exports.NoSuchFrameException = exports.NoSuchElementException = exports.NoSuchAlertException = exports.MoveTargetOutOfBoundsException = exports.InvalidSessionIdException = exports.InvalidSelectorException = exports.InvalidArgumentException = exports.Exception = void 0; + var Exception = class extends Error { + error; + message; + stacktrace; + constructor(error, message, stacktrace) { + super(); + this.error = error; + this.message = message; + this.stacktrace = stacktrace; + } + toErrorResponse(commandId) { + return { + type: "error", + id: commandId, + error: this.error, + message: this.message, + stacktrace: this.stacktrace + }; + } + }; + exports.Exception = Exception; + var InvalidArgumentException = class extends Exception { + constructor(message, stacktrace) { + super("invalid argument", message, stacktrace); + } + }; + exports.InvalidArgumentException = InvalidArgumentException; + var InvalidSelectorException = class extends Exception { + constructor(message, stacktrace) { + super("invalid selector", message, stacktrace); + } + }; + exports.InvalidSelectorException = InvalidSelectorException; + var InvalidSessionIdException = class extends Exception { + constructor(message, stacktrace) { + super("invalid session id", message, stacktrace); + } + }; + exports.InvalidSessionIdException = InvalidSessionIdException; + var MoveTargetOutOfBoundsException = class extends Exception { + constructor(message, stacktrace) { + super("move target out of bounds", message, stacktrace); + } + }; + exports.MoveTargetOutOfBoundsException = MoveTargetOutOfBoundsException; + var NoSuchAlertException = class extends Exception { + constructor(message, stacktrace) { + super("no such alert", message, stacktrace); + } + }; + exports.NoSuchAlertException = NoSuchAlertException; + var NoSuchElementException = class extends Exception { + constructor(message, stacktrace) { + super("no such element", message, stacktrace); + } + }; + exports.NoSuchElementException = NoSuchElementException; + var NoSuchFrameException = class extends Exception { + constructor(message, stacktrace) { + super("no such frame", message, stacktrace); + } + }; + exports.NoSuchFrameException = NoSuchFrameException; + var NoSuchHandleException = class extends Exception { + constructor(message, stacktrace) { + super("no such handle", message, stacktrace); + } + }; + exports.NoSuchHandleException = NoSuchHandleException; + var NoSuchHistoryEntryException = class extends Exception { + constructor(message, stacktrace) { + super("no such history entry", message, stacktrace); + } + }; + exports.NoSuchHistoryEntryException = NoSuchHistoryEntryException; + var NoSuchInterceptException = class extends Exception { + constructor(message, stacktrace) { + super("no such intercept", message, stacktrace); + } + }; + exports.NoSuchInterceptException = NoSuchInterceptException; + var NoSuchNodeException = class extends Exception { + constructor(message, stacktrace) { + super("no such node", message, stacktrace); + } + }; + exports.NoSuchNodeException = NoSuchNodeException; + var NoSuchRequestException = class extends Exception { + constructor(message, stacktrace) { + super("no such request", message, stacktrace); + } + }; + exports.NoSuchRequestException = NoSuchRequestException; + var NoSuchScriptException = class extends Exception { + constructor(message, stacktrace) { + super("no such script", message, stacktrace); + } + }; + exports.NoSuchScriptException = NoSuchScriptException; + var NoSuchUserContextException = class extends Exception { + constructor(message, stacktrace) { + super("no such user context", message, stacktrace); + } + }; + exports.NoSuchUserContextException = NoSuchUserContextException; + var SessionNotCreatedException = class extends Exception { + constructor(message, stacktrace) { + super("session not created", message, stacktrace); + } + }; + exports.SessionNotCreatedException = SessionNotCreatedException; + var UnknownCommandException = class extends Exception { + constructor(message, stacktrace) { + super("unknown command", message, stacktrace); + } + }; + exports.UnknownCommandException = UnknownCommandException; + var UnknownErrorException = class extends Exception { + constructor(message, stacktrace = new Error().stack) { + super("unknown error", message, stacktrace); + } + }; + exports.UnknownErrorException = UnknownErrorException; + var UnableToCaptureScreenException = class extends Exception { + constructor(message, stacktrace) { + super("unable to capture screen", message, stacktrace); + } + }; + exports.UnableToCaptureScreenException = UnableToCaptureScreenException; + var UnableToCloseBrowserException = class extends Exception { + constructor(message, stacktrace) { + super("unable to close browser", message, stacktrace); + } + }; + exports.UnableToCloseBrowserException = UnableToCloseBrowserException; + var UnsupportedOperationException = class extends Exception { + constructor(message, stacktrace) { + super("unsupported operation", message, stacktrace); + } + }; + exports.UnsupportedOperationException = UnsupportedOperationException; + var NoSuchStoragePartitionException = class extends Exception { + constructor(message, stacktrace) { + super("no such storage partition", message, stacktrace); + } + }; + exports.NoSuchStoragePartitionException = NoSuchStoragePartitionException; + var UnableToSetCookieException = class extends Exception { + constructor(message, stacktrace) { + super("unable to set cookie", message, stacktrace); + } + }; + exports.UnableToSetCookieException = UnableToSetCookieException; + var UnableToSetFileInputException = class extends Exception { + constructor(message, stacktrace) { + super("unable to set file input", message, stacktrace); + } + }; + exports.UnableToSetFileInputException = UnableToSetFileInputException; + var UnderspecifiedStoragePartitionException = class extends Exception { + constructor(message, stacktrace) { + super("underspecified storage partition", message, stacktrace); + } + }; + exports.UnderspecifiedStoragePartitionException = UnderspecifiedStoragePartitionException; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/generated/webdriver-bidi-permissions.js +var require_webdriver_bidi_permissions = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/generated/webdriver-bidi-permissions.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/generated/webdriver-bidi-bluetooth.js +var require_webdriver_bidi_bluetooth = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/generated/webdriver-bidi-bluetooth.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/protocol.js +var require_protocol = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/protocol/protocol.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding(result, mod, k); + } + __setModuleDefault(result, mod); + return result; + }; + var __exportStar = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) + __createBinding(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ChromiumBidi = exports.Cdp = void 0; + exports.Cdp = __importStar(require_cdp()); + exports.ChromiumBidi = __importStar(require_chromium_bidi()); + __exportStar(require_webdriver_bidi(), exports); + __exportStar(require_ErrorResponse(), exports); + __exportStar(require_webdriver_bidi_permissions(), exports); + __exportStar(require_webdriver_bidi_bluetooth(), exports); + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/BidiNoOpParser.js +var require_BidiNoOpParser = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/BidiNoOpParser.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BidiNoOpParser = void 0; + var BidiNoOpParser = class { + // Bluetooth domain + // keep-sorted start block=yes + parseHandleRequestDevicePromptParams(params) { + return params; + } + // keep-sorted end + // Browser domain + // keep-sorted start block=yes + parseRemoveUserContextParams(params) { + return params; + } + // keep-sorted end + // Browsing Context domain + // keep-sorted start block=yes + parseActivateParams(params) { + return params; + } + parseCaptureScreenshotParams(params) { + return params; + } + parseCloseParams(params) { + return params; + } + parseCreateParams(params) { + return params; + } + parseGetTreeParams(params) { + return params; + } + parseHandleUserPromptParams(params) { + return params; + } + parseLocateNodesParams(params) { + return params; + } + parseNavigateParams(params) { + return params; + } + parsePrintParams(params) { + return params; + } + parseReloadParams(params) { + return params; + } + parseSetViewportParams(params) { + return params; + } + parseTraverseHistoryParams(params) { + return params; + } + // keep-sorted end + // CDP domain + // keep-sorted start block=yes + parseGetSessionParams(params) { + return params; + } + parseResolveRealmParams(params) { + return params; + } + parseSendCommandParams(params) { + return params; + } + // keep-sorted end + // Script domain + // keep-sorted start block=yes + parseAddPreloadScriptParams(params) { + return params; + } + parseCallFunctionParams(params) { + return params; + } + parseDisownParams(params) { + return params; + } + parseEvaluateParams(params) { + return params; + } + parseGetRealmsParams(params) { + return params; + } + parseRemovePreloadScriptParams(params) { + return params; + } + // keep-sorted end + // Input domain + // keep-sorted start block=yes + parsePerformActionsParams(params) { + return params; + } + parseReleaseActionsParams(params) { + return params; + } + parseSetFilesParams(params) { + return params; + } + // keep-sorted end + // Network domain + // keep-sorted start block=yes + parseAddInterceptParams(params) { + return params; + } + parseContinueRequestParams(params) { + return params; + } + parseContinueResponseParams(params) { + return params; + } + parseContinueWithAuthParams(params) { + return params; + } + parseFailRequestParams(params) { + return params; + } + parseProvideResponseParams(params) { + return params; + } + parseRemoveInterceptParams(params) { + return params; + } + parseSetCacheBehavior(params) { + return params; + } + // keep-sorted end + // Permissions domain + // keep-sorted start block=yes + parseSetPermissionsParams(params) { + return params; + } + // keep-sorted end + // Session domain + // keep-sorted start block=yes + parseSubscribeParams(params) { + return params; + } + // keep-sorted end + // Storage domain + // keep-sorted start block=yes + parseDeleteCookiesParams(params) { + return params; + } + parseGetCookiesParams(params) { + return params; + } + parseSetCookieParams(params) { + return params; + } + }; + exports.BidiNoOpParser = BidiNoOpParser; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/browser/BrowserProcessor.js +var require_BrowserProcessor = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/browser/BrowserProcessor.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BrowserProcessor = void 0; + var protocol_js_1 = require_protocol(); + var BrowserProcessor = class { + #browserCdpClient; + constructor(browserCdpClient) { + this.#browserCdpClient = browserCdpClient; + } + close() { + setTimeout(() => this.#browserCdpClient.sendCommand("Browser.close"), 0); + return {}; + } + async createUserContext(params) { + const request = { + proxyServer: params["goog:proxyServer"] ?? void 0 + }; + const proxyBypassList = params["goog:proxyBypassList"] ?? void 0; + if (proxyBypassList) { + request.proxyBypassList = proxyBypassList.join(","); + } + const context = await this.#browserCdpClient.sendCommand("Target.createBrowserContext", request); + return { + userContext: context.browserContextId + }; + } + async removeUserContext(params) { + const userContext = params.userContext; + if (userContext === "default") { + throw new protocol_js_1.InvalidArgumentException("`default` user context cannot be removed"); + } + try { + await this.#browserCdpClient.sendCommand("Target.disposeBrowserContext", { + browserContextId: userContext + }); + } catch (err) { + if (err.message.startsWith("Failed to find context with id")) { + throw new protocol_js_1.NoSuchUserContextException(err.message); + } + throw err; + } + return {}; + } + async getUserContexts() { + const result = await this.#browserCdpClient.sendCommand("Target.getBrowserContexts"); + return { + userContexts: [ + { + userContext: "default" + }, + ...result.browserContextIds.map((id) => { + return { + userContext: id + }; + }) + ] + }; + } + }; + exports.BrowserProcessor = BrowserProcessor; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/cdp/CdpProcessor.js +var require_CdpProcessor = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/cdp/CdpProcessor.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.CdpProcessor = void 0; + var protocol_js_1 = require_protocol(); + var CdpProcessor = class { + #browsingContextStorage; + #realmStorage; + #cdpConnection; + #browserCdpClient; + constructor(browsingContextStorage, realmStorage, cdpConnection, browserCdpClient) { + this.#browsingContextStorage = browsingContextStorage; + this.#realmStorage = realmStorage; + this.#cdpConnection = cdpConnection; + this.#browserCdpClient = browserCdpClient; + } + getSession(params) { + const context = params.context; + const sessionId = this.#browsingContextStorage.getContext(context).cdpTarget.cdpSessionId; + if (sessionId === void 0) { + return {}; + } + return { session: sessionId }; + } + resolveRealm(params) { + const context = params.realm; + const realm = this.#realmStorage.getRealm({ realmId: context }); + if (realm === void 0) { + throw new protocol_js_1.UnknownErrorException(`Could not find realm ${params.realm}`); + } + return { executionContextId: realm.executionContextId }; + } + async sendCommand(params) { + const client = params.session ? this.#cdpConnection.getCdpClient(params.session) : this.#browserCdpClient; + const result = await client.sendCommand(params.method, params.params); + return { + result, + session: params.session + }; + } + }; + exports.CdpProcessor = CdpProcessor; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/context/BrowsingContextProcessor.js +var require_BrowsingContextProcessor = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/context/BrowsingContextProcessor.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BrowsingContextProcessor = void 0; + var protocol_js_1 = require_protocol(); + var BrowsingContextProcessor = class { + #browserCdpClient; + #browsingContextStorage; + #eventManager; + constructor(browserCdpClient, browsingContextStorage, eventManager) { + this.#browserCdpClient = browserCdpClient; + this.#browsingContextStorage = browsingContextStorage; + this.#eventManager = eventManager; + this.#eventManager.addSubscribeHook(protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.ContextCreated, this.#onContextCreatedSubscribeHook.bind(this)); + } + getTree(params) { + const resultContexts = params.root === void 0 ? this.#browsingContextStorage.getTopLevelContexts() : [this.#browsingContextStorage.getContext(params.root)]; + return { + contexts: resultContexts.map((c) => c.serializeToBidiValue(params.maxDepth ?? Number.MAX_VALUE)) + }; + } + async create(params) { + let referenceContext; + let userContext = "default"; + if (params.referenceContext !== void 0) { + referenceContext = this.#browsingContextStorage.getContext(params.referenceContext); + if (!referenceContext.isTopLevelContext()) { + throw new protocol_js_1.InvalidArgumentException(`referenceContext should be a top-level context`); + } + userContext = referenceContext.userContext; + } + if (params.userContext !== void 0) { + userContext = params.userContext; + } + const existingContexts = this.#browsingContextStorage.getAllContexts().filter((context2) => context2.userContext === userContext); + let newWindow = false; + switch (params.type) { + case "tab": + newWindow = false; + break; + case "window": + newWindow = true; + break; + } + if (!existingContexts.length) { + newWindow = true; + } + let result; + try { + result = await this.#browserCdpClient.sendCommand("Target.createTarget", { + url: "about:blank", + newWindow, + browserContextId: userContext === "default" ? void 0 : userContext, + background: params.background === true + }); + } catch (err) { + if ( + // See https://source.chromium.org/chromium/chromium/src/+/main:chrome/browser/devtools/protocol/target_handler.cc;l=90;drc=e80392ac11e48a691f4309964cab83a3a59e01c8 + err.message.startsWith("Failed to find browser context with id") || // See https://source.chromium.org/chromium/chromium/src/+/main:headless/lib/browser/protocol/target_handler.cc;l=49;drc=e80392ac11e48a691f4309964cab83a3a59e01c8 + err.message === "browserContextId" + ) { + throw new protocol_js_1.NoSuchUserContextException(`The context ${userContext} was not found`); + } + throw err; + } + const contextId = result.targetId; + const context = this.#browsingContextStorage.getContext(contextId); + await context.lifecycleLoaded(); + return { context: context.id }; + } + navigate(params) { + const context = this.#browsingContextStorage.getContext(params.context); + return context.navigate( + params.url, + params.wait ?? "none" + /* BrowsingContext.ReadinessState.None */ + ); + } + reload(params) { + const context = this.#browsingContextStorage.getContext(params.context); + return context.reload( + params.ignoreCache ?? false, + params.wait ?? "none" + /* BrowsingContext.ReadinessState.None */ + ); + } + async activate(params) { + const context = this.#browsingContextStorage.getContext(params.context); + if (!context.isTopLevelContext()) { + throw new protocol_js_1.InvalidArgumentException("Activation is only supported on the top-level context"); + } + await context.activate(); + return {}; + } + async captureScreenshot(params) { + const context = this.#browsingContextStorage.getContext(params.context); + return await context.captureScreenshot(params); + } + async print(params) { + const context = this.#browsingContextStorage.getContext(params.context); + return await context.print(params); + } + async setViewport(params) { + const context = this.#browsingContextStorage.getContext(params.context); + if (!context.isTopLevelContext()) { + throw new protocol_js_1.InvalidArgumentException("Emulating viewport is only supported on the top-level context"); + } + await context.setViewport(params.viewport, params.devicePixelRatio); + return {}; + } + async traverseHistory(params) { + const context = this.#browsingContextStorage.getContext(params.context); + if (!context) { + throw new protocol_js_1.InvalidArgumentException(`No browsing context with id ${params.context}`); + } + if (!context.isTopLevelContext()) { + throw new protocol_js_1.InvalidArgumentException("Traversing history is only supported on the top-level context"); + } + await context.traverseHistory(params.delta); + return {}; + } + async handleUserPrompt(params) { + const context = this.#browsingContextStorage.getContext(params.context); + try { + await context.handleUserPrompt(params.accept, params.userText); + } catch (error) { + if (error.message?.includes("No dialog is showing")) { + throw new protocol_js_1.NoSuchAlertException("No dialog is showing"); + } + throw error; + } + return {}; + } + async close(params) { + const context = this.#browsingContextStorage.getContext(params.context); + if (!context.isTopLevelContext()) { + throw new protocol_js_1.InvalidArgumentException(`Non top-level browsing context ${context.id} cannot be closed.`); + } + try { + const detachedFromTargetPromise = new Promise((resolve) => { + const onContextDestroyed = (event) => { + if (event.targetId === params.context) { + this.#browserCdpClient.off("Target.detachedFromTarget", onContextDestroyed); + resolve(); + } + }; + this.#browserCdpClient.on("Target.detachedFromTarget", onContextDestroyed); + }); + if (params.promptUnload) { + await context.close(); + } else { + await this.#browserCdpClient.sendCommand("Target.closeTarget", { + targetId: params.context + }); + } + await detachedFromTargetPromise; + } catch (error) { + if (!(error.code === -32e3 && error.message === "Not attached to an active page")) { + throw error; + } + } + return {}; + } + async locateNodes(params) { + const context = this.#browsingContextStorage.getContext(params.context); + return await context.locateNodes(params); + } + #onContextCreatedSubscribeHook(contextId) { + const context = this.#browsingContextStorage.getContext(contextId); + const contextsToReport = [ + context, + ...this.#browsingContextStorage.getContext(contextId).allChildren + ]; + contextsToReport.forEach((context2) => { + this.#eventManager.registerEvent({ + type: "event", + method: protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.ContextCreated, + params: context2.serializeToBidiValue() + }, context2.id); + }); + return Promise.resolve(); + } + }; + exports.BrowsingContextProcessor = BrowsingContextProcessor; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/assert.js +var require_assert = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/assert.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.assert = assert2; + function assert2(predicate, message) { + if (!predicate) { + throw new Error(message ?? "Internal assertion failed."); + } + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/GraphemeTools.js +var require_GraphemeTools = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/GraphemeTools.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isSingleComplexGrapheme = isSingleComplexGrapheme; + exports.isSingleGrapheme = isSingleGrapheme; + function isSingleComplexGrapheme(value) { + return isSingleGrapheme(value) && value.length > 1; + } + function isSingleGrapheme(value) { + const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" }); + return [...segmenter.segment(value)].length === 1; + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/InputSource.js +var require_InputSource = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/InputSource.js"(exports) { + "use strict"; + init_cjs_shim(); + var _a3; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.WheelSource = exports.PointerSource = exports.KeySource = exports.NoneSource = void 0; + var NoneSource = class { + type = "none"; + }; + exports.NoneSource = NoneSource; + var KeySource = class { + type = "key"; + pressed = /* @__PURE__ */ new Set(); + // This is a bitfield that matches the modifiers parameter of + // https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchKeyEvent + #modifiers = 0; + get modifiers() { + return this.#modifiers; + } + get alt() { + return (this.#modifiers & 1) === 1; + } + set alt(value) { + this.#setModifier(value, 1); + } + get ctrl() { + return (this.#modifiers & 2) === 2; + } + set ctrl(value) { + this.#setModifier(value, 2); + } + get meta() { + return (this.#modifiers & 4) === 4; + } + set meta(value) { + this.#setModifier(value, 4); + } + get shift() { + return (this.#modifiers & 8) === 8; + } + set shift(value) { + this.#setModifier(value, 8); + } + #setModifier(value, bit) { + if (value) { + this.#modifiers |= bit; + } else { + this.#modifiers &= ~bit; + } + } + }; + exports.KeySource = KeySource; + var _clickContexts; + var PointerSource = class { + constructor(id, subtype) { + __publicField(this, "type", "pointer"); + __publicField(this, "subtype"); + __publicField(this, "pointerId"); + __publicField(this, "pressed", /* @__PURE__ */ new Set()); + __publicField(this, "x", 0); + __publicField(this, "y", 0); + __publicField(this, "radiusX"); + __publicField(this, "radiusY"); + __publicField(this, "force"); + __privateAdd(this, _clickContexts, /* @__PURE__ */ new Map()); + this.pointerId = id; + this.subtype = subtype; + } + // This is a bitfield that matches the buttons parameter of + // https://chromedevtools.github.io/devtools-protocol/tot/Input/#method-dispatchMouseEvent + get buttons() { + let buttons = 0; + for (const button of this.pressed) { + switch (button) { + case 0: + buttons |= 1; + break; + case 1: + buttons |= 4; + break; + case 2: + buttons |= 2; + break; + case 3: + buttons |= 8; + break; + case 4: + buttons |= 16; + break; + } + } + return buttons; + } + setClickCount(button, context) { + let storedContext = __privateGet(this, _clickContexts).get(button); + if (!storedContext || storedContext.compare(context)) { + storedContext = context; + } + ++storedContext.count; + __privateGet(this, _clickContexts).set(button, storedContext); + return storedContext.count; + } + getClickCount(button) { + return __privateGet(this, _clickContexts).get(button)?.count ?? 0; + } + }; + _clickContexts = new WeakMap(); + // --- Platform-specific code starts here --- + // Input.dispatchMouseEvent doesn't know the concept of double click, so we + // need to create the logic, similar to how it's done for OSes: + // https://source.chromium.org/chromium/chromium/src/+/refs/heads/main:ui/events/event.cc;l=479 + __publicField(PointerSource, "ClickContext", class ClickContext { + static #DOUBLE_CLICK_TIME_MS = 500; + static #MAX_DOUBLE_CLICK_RADIUS = 2; + count = 0; + #x; + #y; + #time; + constructor(x, y, time) { + this.#x = x; + this.#y = y; + this.#time = time; + } + compare(context) { + return ( + // The click needs to be within a certain amount of ms. + context.#time - this.#time > ClickContext.#DOUBLE_CLICK_TIME_MS || // The click needs to be within a certain square radius. + Math.abs(context.#x - this.#x) > ClickContext.#MAX_DOUBLE_CLICK_RADIUS || Math.abs(context.#y - this.#y) > ClickContext.#MAX_DOUBLE_CLICK_RADIUS + ); + } + }); + exports.PointerSource = PointerSource; + _a3 = PointerSource; + var WheelSource = class { + type = "wheel"; + }; + exports.WheelSource = WheelSource; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/keyUtils.js +var require_keyUtils = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/keyUtils.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getNormalizedKey = getNormalizedKey; + exports.getKeyCode = getKeyCode; + exports.getKeyLocation = getKeyLocation; + function getNormalizedKey(value) { + switch (value) { + case "\uE000": + return "Unidentified"; + case "\uE001": + return "Cancel"; + case "\uE002": + return "Help"; + case "\uE003": + return "Backspace"; + case "\uE004": + return "Tab"; + case "\uE005": + return "Clear"; + case "\uE006": + case "\uE007": + return "Enter"; + case "\uE008": + return "Shift"; + case "\uE009": + return "Control"; + case "\uE00A": + return "Alt"; + case "\uE00B": + return "Pause"; + case "\uE00C": + return "Escape"; + case "\uE00D": + return " "; + case "\uE00E": + return "PageUp"; + case "\uE00F": + return "PageDown"; + case "\uE010": + return "End"; + case "\uE011": + return "Home"; + case "\uE012": + return "ArrowLeft"; + case "\uE013": + return "ArrowUp"; + case "\uE014": + return "ArrowRight"; + case "\uE015": + return "ArrowDown"; + case "\uE016": + return "Insert"; + case "\uE017": + return "Delete"; + case "\uE018": + return ";"; + case "\uE019": + return "="; + case "\uE01A": + return "0"; + case "\uE01B": + return "1"; + case "\uE01C": + return "2"; + case "\uE01D": + return "3"; + case "\uE01E": + return "4"; + case "\uE01F": + return "5"; + case "\uE020": + return "6"; + case "\uE021": + return "7"; + case "\uE022": + return "8"; + case "\uE023": + return "9"; + case "\uE024": + return "*"; + case "\uE025": + return "+"; + case "\uE026": + return ","; + case "\uE027": + return "-"; + case "\uE028": + return "."; + case "\uE029": + return "/"; + case "\uE031": + return "F1"; + case "\uE032": + return "F2"; + case "\uE033": + return "F3"; + case "\uE034": + return "F4"; + case "\uE035": + return "F5"; + case "\uE036": + return "F6"; + case "\uE037": + return "F7"; + case "\uE038": + return "F8"; + case "\uE039": + return "F9"; + case "\uE03A": + return "F10"; + case "\uE03B": + return "F11"; + case "\uE03C": + return "F12"; + case "\uE03D": + return "Meta"; + case "\uE040": + return "ZenkakuHankaku"; + case "\uE050": + return "Shift"; + case "\uE051": + return "Control"; + case "\uE052": + return "Alt"; + case "\uE053": + return "Meta"; + case "\uE054": + return "PageUp"; + case "\uE055": + return "PageDown"; + case "\uE056": + return "End"; + case "\uE057": + return "Home"; + case "\uE058": + return "ArrowLeft"; + case "\uE059": + return "ArrowUp"; + case "\uE05A": + return "ArrowRight"; + case "\uE05B": + return "ArrowDown"; + case "\uE05C": + return "Insert"; + case "\uE05D": + return "Delete"; + default: + return value; + } + } + function getKeyCode(key) { + switch (key) { + case "`": + case "~": + return "Backquote"; + case "\\": + case "|": + return "Backslash"; + case "\uE003": + return "Backspace"; + case "[": + case "{": + return "BracketLeft"; + case "]": + case "}": + return "BracketRight"; + case ",": + case "<": + return "Comma"; + case "0": + case ")": + return "Digit0"; + case "1": + case "!": + return "Digit1"; + case "2": + case "@": + return "Digit2"; + case "3": + case "#": + return "Digit3"; + case "4": + case "$": + return "Digit4"; + case "5": + case "%": + return "Digit5"; + case "6": + case "^": + return "Digit6"; + case "7": + case "&": + return "Digit7"; + case "8": + case "*": + return "Digit8"; + case "9": + case "(": + return "Digit9"; + case "=": + case "+": + return "Equal"; + case ">": + return "IntlBackslash"; + case "a": + case "A": + return "KeyA"; + case "b": + case "B": + return "KeyB"; + case "c": + case "C": + return "KeyC"; + case "d": + case "D": + return "KeyD"; + case "e": + case "E": + return "KeyE"; + case "f": + case "F": + return "KeyF"; + case "g": + case "G": + return "KeyG"; + case "h": + case "H": + return "KeyH"; + case "i": + case "I": + return "KeyI"; + case "j": + case "J": + return "KeyJ"; + case "k": + case "K": + return "KeyK"; + case "l": + case "L": + return "KeyL"; + case "m": + case "M": + return "KeyM"; + case "n": + case "N": + return "KeyN"; + case "o": + case "O": + return "KeyO"; + case "p": + case "P": + return "KeyP"; + case "q": + case "Q": + return "KeyQ"; + case "r": + case "R": + return "KeyR"; + case "s": + case "S": + return "KeyS"; + case "t": + case "T": + return "KeyT"; + case "u": + case "U": + return "KeyU"; + case "v": + case "V": + return "KeyV"; + case "w": + case "W": + return "KeyW"; + case "x": + case "X": + return "KeyX"; + case "y": + case "Y": + return "KeyY"; + case "z": + case "Z": + return "KeyZ"; + case "-": + case "_": + return "Minus"; + case ".": + return "Period"; + case "'": + case '"': + return "Quote"; + case ";": + case ":": + return "Semicolon"; + case "/": + case "?": + return "Slash"; + case "\uE00A": + return "AltLeft"; + case "\uE052": + return "AltRight"; + case "\uE009": + return "ControlLeft"; + case "\uE051": + return "ControlRight"; + case "\uE006": + return "Enter"; + case "\uE00B": + return "Pause"; + case "\uE03D": + return "MetaLeft"; + case "\uE053": + return "MetaRight"; + case "\uE008": + return "ShiftLeft"; + case "\uE050": + return "ShiftRight"; + case " ": + case "\uE00D": + return "Space"; + case "\uE004": + return "Tab"; + case "\uE017": + return "Delete"; + case "\uE010": + return "End"; + case "\uE002": + return "Help"; + case "\uE011": + return "Home"; + case "\uE016": + return "Insert"; + case "\uE00F": + return "PageDown"; + case "\uE00E": + return "PageUp"; + case "\uE015": + return "ArrowDown"; + case "\uE012": + return "ArrowLeft"; + case "\uE014": + return "ArrowRight"; + case "\uE013": + return "ArrowUp"; + case "\uE00C": + return "Escape"; + case "\uE031": + return "F1"; + case "\uE032": + return "F2"; + case "\uE033": + return "F3"; + case "\uE034": + return "F4"; + case "\uE035": + return "F5"; + case "\uE036": + return "F6"; + case "\uE037": + return "F7"; + case "\uE038": + return "F8"; + case "\uE039": + return "F9"; + case "\uE03A": + return "F10"; + case "\uE03B": + return "F11"; + case "\uE03C": + return "F12"; + case "\uE019": + return "NumpadEqual"; + case "\uE01A": + case "\uE05C": + return "Numpad0"; + case "\uE01B": + case "\uE056": + return "Numpad1"; + case "\uE01C": + case "\uE05B": + return "Numpad2"; + case "\uE01D": + case "\uE055": + return "Numpad3"; + case "\uE01E": + case "\uE058": + return "Numpad4"; + case "\uE01F": + return "Numpad5"; + case "\uE020": + case "\uE05A": + return "Numpad6"; + case "\uE021": + case "\uE057": + return "Numpad7"; + case "\uE022": + case "\uE059": + return "Numpad8"; + case "\uE023": + case "\uE054": + return "Numpad9"; + case "\uE025": + return "NumpadAdd"; + case "\uE026": + return "NumpadComma"; + case "\uE028": + case "\uE05D": + return "NumpadDecimal"; + case "\uE029": + return "NumpadDivide"; + case "\uE007": + return "NumpadEnter"; + case "\uE024": + return "NumpadMultiply"; + case "\uE027": + return "NumpadSubtract"; + default: + return; + } + } + function getKeyLocation(key) { + switch (key) { + case "\uE007": + case "\uE008": + case "\uE009": + case "\uE00A": + case "\uE03D": + return 1; + case "\uE019": + case "\uE01A": + case "\uE01B": + case "\uE01C": + case "\uE01D": + case "\uE01E": + case "\uE01F": + case "\uE020": + case "\uE021": + case "\uE022": + case "\uE023": + case "\uE024": + case "\uE025": + case "\uE026": + case "\uE027": + case "\uE028": + case "\uE029": + case "\uE054": + case "\uE055": + case "\uE056": + case "\uE057": + case "\uE058": + case "\uE059": + case "\uE05A": + case "\uE05B": + case "\uE05C": + case "\uE05D": + return 3; + case "\uE050": + case "\uE051": + case "\uE052": + case "\uE053": + return 2; + default: + return 0; + } + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/USKeyboardLayout.js +var require_USKeyboardLayout = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/USKeyboardLayout.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.KeyToKeyCode = void 0; + exports.KeyToKeyCode = { + "0": 48, + "1": 49, + "2": 50, + "3": 51, + "4": 52, + "5": 53, + "6": 54, + "7": 55, + "8": 56, + "9": 57, + Abort: 3, + Help: 6, + Backspace: 8, + Tab: 9, + Numpad5: 12, + NumpadEnter: 13, + Enter: 13, + "\\r": 13, + "\\n": 13, + ShiftLeft: 16, + ShiftRight: 16, + ControlLeft: 17, + ControlRight: 17, + AltLeft: 18, + AltRight: 18, + Pause: 19, + CapsLock: 20, + Escape: 27, + Convert: 28, + NonConvert: 29, + Space: 32, + Numpad9: 33, + PageUp: 33, + Numpad3: 34, + PageDown: 34, + End: 35, + Numpad1: 35, + Home: 36, + Numpad7: 36, + ArrowLeft: 37, + Numpad4: 37, + Numpad8: 38, + ArrowUp: 38, + ArrowRight: 39, + Numpad6: 39, + Numpad2: 40, + ArrowDown: 40, + Select: 41, + Open: 43, + PrintScreen: 44, + Insert: 45, + Numpad0: 45, + Delete: 46, + NumpadDecimal: 46, + Digit0: 48, + Digit1: 49, + Digit2: 50, + Digit3: 51, + Digit4: 52, + Digit5: 53, + Digit6: 54, + Digit7: 55, + Digit8: 56, + Digit9: 57, + KeyA: 65, + KeyB: 66, + KeyC: 67, + KeyD: 68, + KeyE: 69, + KeyF: 70, + KeyG: 71, + KeyH: 72, + KeyI: 73, + KeyJ: 74, + KeyK: 75, + KeyL: 76, + KeyM: 77, + KeyN: 78, + KeyO: 79, + KeyP: 80, + KeyQ: 81, + KeyR: 82, + KeyS: 83, + KeyT: 84, + KeyU: 85, + KeyV: 86, + KeyW: 87, + KeyX: 88, + KeyY: 89, + KeyZ: 90, + MetaLeft: 91, + MetaRight: 92, + ContextMenu: 93, + NumpadMultiply: 106, + NumpadAdd: 107, + NumpadSubtract: 109, + NumpadDivide: 111, + F1: 112, + F2: 113, + F3: 114, + F4: 115, + F5: 116, + F6: 117, + F7: 118, + F8: 119, + F9: 120, + F10: 121, + F11: 122, + F12: 123, + F13: 124, + F14: 125, + F15: 126, + F16: 127, + F17: 128, + F18: 129, + F19: 130, + F20: 131, + F21: 132, + F22: 133, + F23: 134, + F24: 135, + NumLock: 144, + ScrollLock: 145, + AudioVolumeMute: 173, + AudioVolumeDown: 174, + AudioVolumeUp: 175, + MediaTrackNext: 176, + MediaTrackPrevious: 177, + MediaStop: 178, + MediaPlayPause: 179, + Semicolon: 186, + Equal: 187, + NumpadEqual: 187, + Comma: 188, + Minus: 189, + Period: 190, + Slash: 191, + Backquote: 192, + BracketLeft: 219, + Backslash: 220, + BracketRight: 221, + Quote: 222, + AltGraph: 225, + Props: 247, + Cancel: 3, + Clear: 12, + Shift: 16, + Control: 17, + Alt: 18, + Accept: 30, + ModeChange: 31, + " ": 32, + Print: 42, + Execute: 43, + "\\u0000": 46, + a: 65, + b: 66, + c: 67, + d: 68, + e: 69, + f: 70, + g: 71, + h: 72, + i: 73, + j: 74, + k: 75, + l: 76, + m: 77, + n: 78, + o: 79, + p: 80, + q: 81, + r: 82, + s: 83, + t: 84, + u: 85, + v: 86, + w: 87, + x: 88, + y: 89, + z: 90, + Meta: 91, + "*": 106, + "+": 107, + "-": 109, + "/": 111, + ";": 186, + "=": 187, + ",": 188, + ".": 190, + "`": 192, + "[": 219, + "\\\\": 220, + "]": 221, + "'": 222, + Attn: 246, + CrSel: 247, + ExSel: 248, + EraseEof: 249, + Play: 250, + ZoomOut: 251, + ")": 48, + "!": 49, + "@": 50, + "#": 51, + $: 52, + "%": 53, + "^": 54, + "&": 55, + "(": 57, + A: 65, + B: 66, + C: 67, + D: 68, + E: 69, + F: 70, + G: 71, + H: 72, + I: 73, + J: 74, + K: 75, + L: 76, + M: 77, + N: 78, + O: 79, + P: 80, + Q: 81, + R: 82, + S: 83, + T: 84, + U: 85, + V: 86, + W: 87, + X: 88, + Y: 89, + Z: 90, + ":": 186, + "<": 188, + _: 189, + ">": 190, + "?": 191, + "~": 192, + "{": 219, + "|": 220, + "}": 221, + '"': 222, + Camera: 44, + EndCall: 95, + VolumeDown: 182, + VolumeUp: 183 + }; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/ActionDispatcher.js +var require_ActionDispatcher = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/ActionDispatcher.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ActionDispatcher = void 0; + var protocol_js_1 = require_protocol(); + var assert_js_1 = require_assert(); + var GraphemeTools_js_1 = require_GraphemeTools(); + var InputSource_js_1 = require_InputSource(); + var keyUtils_js_1 = require_keyUtils(); + var USKeyboardLayout_js_1 = require_USKeyboardLayout(); + var CALCULATE_IN_VIEW_CENTER_PT_DECL = ((i) => { + const t = i.getClientRects()[0], e = Math.max(0, Math.min(t.x, t.x + t.width)), n = Math.min(window.innerWidth, Math.max(t.x, t.x + t.width)), h = Math.max(0, Math.min(t.y, t.y + t.height)), m = Math.min(window.innerHeight, Math.max(t.y, t.y + t.height)); + return [e + (n - e >> 1), h + (m - h >> 1)]; + }).toString(); + var IS_MAC_DECL = (() => { + return navigator.platform.toLowerCase().includes("mac"); + }).toString(); + async function getElementCenter(context, element) { + const sandbox = await context.getOrCreateSandbox(void 0); + const result = await sandbox.callFunction(CALCULATE_IN_VIEW_CENTER_PT_DECL, false, { type: "undefined" }, [element]); + if (result.type === "exception") { + throw new protocol_js_1.NoSuchElementException(`Origin element ${element.sharedId} was not found`); + } + (0, assert_js_1.assert)(result.result.type === "array"); + (0, assert_js_1.assert)(result.result.value?.[0]?.type === "number"); + (0, assert_js_1.assert)(result.result.value?.[1]?.type === "number"); + const { result: { value: [{ value: x }, { value: y }] } } = result; + return { x, y }; + } + var _tickStart, _tickDuration, _inputState, _context, _isMacOS, _dispatchAction, dispatchAction_fn, _dispatchPointerDownAction, dispatchPointerDownAction_fn, _dispatchPointerUpAction, dispatchPointerUpAction_fn, _dispatchPointerMoveAction, dispatchPointerMoveAction_fn, _getCoordinateFromOrigin, getCoordinateFromOrigin_fn, _dispatchScrollAction, dispatchScrollAction_fn, _dispatchKeyDownAction, dispatchKeyDownAction_fn, _dispatchKeyUpAction, dispatchKeyUpAction_fn; + var ActionDispatcher = class { + constructor(inputState, context, isMacOS) { + __privateAdd(this, _dispatchAction); + __privateAdd(this, _dispatchPointerDownAction); + __privateAdd(this, _dispatchPointerUpAction); + __privateAdd(this, _dispatchPointerMoveAction); + __privateAdd(this, _getCoordinateFromOrigin); + __privateAdd(this, _dispatchScrollAction); + __privateAdd(this, _dispatchKeyDownAction); + __privateAdd(this, _dispatchKeyUpAction); + __privateAdd(this, _tickStart, 0); + __privateAdd(this, _tickDuration, 0); + __privateAdd(this, _inputState, void 0); + __privateAdd(this, _context, void 0); + __privateAdd(this, _isMacOS, void 0); + __privateSet(this, _inputState, inputState); + __privateSet(this, _context, context); + __privateSet(this, _isMacOS, isMacOS); + } + async dispatchActions(optionsByTick) { + await __privateGet(this, _inputState).queue.run(async () => { + for (const options of optionsByTick) { + await this.dispatchTickActions(options); + } + }); + } + async dispatchTickActions(options) { + __privateSet(this, _tickStart, performance.now()); + __privateSet(this, _tickDuration, 0); + for (const { action } of options) { + if ("duration" in action && action.duration !== void 0) { + __privateSet(this, _tickDuration, Math.max(__privateGet(this, _tickDuration), action.duration)); + } + } + const promises = [ + new Promise((resolve) => setTimeout(resolve, __privateGet(this, _tickDuration))) + ]; + for (const option of options) { + promises.push(__privateMethod(this, _dispatchAction, dispatchAction_fn).call(this, option)); + } + await Promise.all(promises); + } + }; + _tickStart = new WeakMap(); + _tickDuration = new WeakMap(); + _inputState = new WeakMap(); + _context = new WeakMap(); + _isMacOS = new WeakMap(); + _dispatchAction = new WeakSet(); + dispatchAction_fn = async function({ id, action }) { + const source = __privateGet(this, _inputState).get(id); + const keyState = __privateGet(this, _inputState).getGlobalKeyState(); + switch (action.type) { + case "keyDown": { + await __privateMethod(this, _dispatchKeyDownAction, dispatchKeyDownAction_fn).call(this, source, action); + __privateGet(this, _inputState).cancelList.push({ + id, + action: { + ...action, + type: "keyUp" + } + }); + break; + } + case "keyUp": { + await __privateMethod(this, _dispatchKeyUpAction, dispatchKeyUpAction_fn).call(this, source, action); + break; + } + case "pause": { + break; + } + case "pointerDown": { + await __privateMethod(this, _dispatchPointerDownAction, dispatchPointerDownAction_fn).call(this, source, keyState, action); + __privateGet(this, _inputState).cancelList.push({ + id, + action: { + ...action, + type: "pointerUp" + } + }); + break; + } + case "pointerMove": { + await __privateMethod(this, _dispatchPointerMoveAction, dispatchPointerMoveAction_fn).call(this, source, keyState, action); + break; + } + case "pointerUp": { + await __privateMethod(this, _dispatchPointerUpAction, dispatchPointerUpAction_fn).call(this, source, keyState, action); + break; + } + case "scroll": { + await __privateMethod(this, _dispatchScrollAction, dispatchScrollAction_fn).call(this, source, keyState, action); + break; + } + } + }; + _dispatchPointerDownAction = new WeakSet(); + dispatchPointerDownAction_fn = async function(source, keyState, action) { + const { button } = action; + if (source.pressed.has(button)) { + return; + } + source.pressed.add(button); + const { x, y, subtype: pointerType } = source; + const { width, height, pressure, twist, tangentialPressure } = action; + const { tiltX, tiltY } = getTilt(action); + const { modifiers } = keyState; + const { radiusX, radiusY } = getRadii(width ?? 1, height ?? 1); + switch (pointerType) { + case "mouse": + case "pen": + await __privateGet(this, _context).cdpTarget.cdpClient.sendCommand("Input.dispatchMouseEvent", { + type: "mousePressed", + x, + y, + modifiers, + button: getCdpButton(button), + buttons: source.buttons, + clickCount: source.setClickCount(button, new InputSource_js_1.PointerSource.ClickContext(x, y, performance.now())), + pointerType, + tangentialPressure, + tiltX, + tiltY, + twist, + force: pressure + }); + break; + case "touch": + await __privateGet(this, _context).cdpTarget.cdpClient.sendCommand("Input.dispatchTouchEvent", { + type: "touchStart", + touchPoints: [ + { + x, + y, + radiusX, + radiusY, + tangentialPressure, + tiltX, + tiltY, + twist, + force: pressure, + id: source.pointerId + } + ], + modifiers + }); + break; + } + source.radiusX = radiusX; + source.radiusY = radiusY; + source.force = pressure; + }; + _dispatchPointerUpAction = new WeakSet(); + dispatchPointerUpAction_fn = function(source, keyState, action) { + const { button } = action; + if (!source.pressed.has(button)) { + return; + } + source.pressed.delete(button); + const { x, y, force, radiusX, radiusY, subtype: pointerType } = source; + const { modifiers } = keyState; + switch (pointerType) { + case "mouse": + case "pen": + return __privateGet(this, _context).cdpTarget.cdpClient.sendCommand("Input.dispatchMouseEvent", { + type: "mouseReleased", + x, + y, + modifiers, + button: getCdpButton(button), + buttons: source.buttons, + clickCount: source.getClickCount(button), + pointerType + }); + case "touch": + return __privateGet(this, _context).cdpTarget.cdpClient.sendCommand("Input.dispatchTouchEvent", { + type: "touchEnd", + touchPoints: [ + { + x, + y, + id: source.pointerId, + force, + radiusX, + radiusY + } + ], + modifiers + }); + } + }; + _dispatchPointerMoveAction = new WeakSet(); + dispatchPointerMoveAction_fn = async function(source, keyState, action) { + const { x: startX, y: startY, subtype: pointerType } = source; + const { width, height, pressure, twist, tangentialPressure, x: offsetX, y: offsetY, origin = "viewport", duration = __privateGet(this, _tickDuration) } = action; + const { tiltX, tiltY } = getTilt(action); + const { radiusX, radiusY } = getRadii(width ?? 1, height ?? 1); + const { targetX, targetY } = await __privateMethod(this, _getCoordinateFromOrigin, getCoordinateFromOrigin_fn).call(this, origin, offsetX, offsetY, startX, startY); + if (targetX < 0 || targetY < 0) { + throw new protocol_js_1.MoveTargetOutOfBoundsException(`Cannot move beyond viewport (x: ${targetX}, y: ${targetY})`); + } + let last; + do { + const ratio = duration > 0 ? (performance.now() - __privateGet(this, _tickStart)) / duration : 1; + last = ratio >= 1; + let x; + let y; + if (last) { + x = targetX; + y = targetY; + } else { + x = Math.round(ratio * (targetX - startX) + startX); + y = Math.round(ratio * (targetY - startY) + startY); + } + if (source.x !== x || source.y !== y) { + const { modifiers } = keyState; + switch (pointerType) { + case "mouse": + await __privateGet(this, _context).cdpTarget.cdpClient.sendCommand("Input.dispatchMouseEvent", { + type: "mouseMoved", + x, + y, + modifiers, + clickCount: 0, + button: getCdpButton(source.pressed.values().next().value ?? 5), + buttons: source.buttons, + pointerType, + tangentialPressure, + tiltX, + tiltY, + twist, + force: pressure + }); + break; + case "pen": + if (source.pressed.size !== 0) { + await __privateGet(this, _context).cdpTarget.cdpClient.sendCommand("Input.dispatchMouseEvent", { + type: "mouseMoved", + x, + y, + modifiers, + clickCount: 0, + button: getCdpButton(source.pressed.values().next().value ?? 5), + buttons: source.buttons, + pointerType, + tangentialPressure, + tiltX, + tiltY, + twist, + force: pressure ?? 0.5 + }); + } + break; + case "touch": + if (source.pressed.size !== 0) { + await __privateGet(this, _context).cdpTarget.cdpClient.sendCommand("Input.dispatchTouchEvent", { + type: "touchMove", + touchPoints: [ + { + x, + y, + radiusX, + radiusY, + tangentialPressure, + tiltX, + tiltY, + twist, + force: pressure, + id: source.pointerId + } + ], + modifiers + }); + } + break; + } + source.x = x; + source.y = y; + source.radiusX = radiusX; + source.radiusY = radiusY; + source.force = pressure; + } + } while (!last); + }; + _getCoordinateFromOrigin = new WeakSet(); + getCoordinateFromOrigin_fn = async function(origin, offsetX, offsetY, startX, startY) { + let targetX; + let targetY; + switch (origin) { + case "viewport": + targetX = offsetX; + targetY = offsetY; + break; + case "pointer": + targetX = startX + offsetX; + targetY = startY + offsetY; + break; + default: { + const { x: posX, y: posY } = await getElementCenter(__privateGet(this, _context), origin.element); + targetX = posX + offsetX; + targetY = posY + offsetY; + break; + } + } + return { targetX, targetY }; + }; + _dispatchScrollAction = new WeakSet(); + dispatchScrollAction_fn = async function(_source, keyState, action) { + const { deltaX: targetDeltaX, deltaY: targetDeltaY, x: offsetX, y: offsetY, origin = "viewport", duration = __privateGet(this, _tickDuration) } = action; + if (origin === "pointer") { + throw new protocol_js_1.InvalidArgumentException('"pointer" origin is invalid for scrolling.'); + } + const { targetX, targetY } = await __privateMethod(this, _getCoordinateFromOrigin, getCoordinateFromOrigin_fn).call(this, origin, offsetX, offsetY, 0, 0); + if (targetX < 0 || targetY < 0) { + throw new protocol_js_1.MoveTargetOutOfBoundsException(`Cannot move beyond viewport (x: ${targetX}, y: ${targetY})`); + } + let currentDeltaX = 0; + let currentDeltaY = 0; + let last; + do { + const ratio = duration > 0 ? (performance.now() - __privateGet(this, _tickStart)) / duration : 1; + last = ratio >= 1; + let deltaX; + let deltaY; + if (last) { + deltaX = targetDeltaX - currentDeltaX; + deltaY = targetDeltaY - currentDeltaY; + } else { + deltaX = Math.round(ratio * targetDeltaX - currentDeltaX); + deltaY = Math.round(ratio * targetDeltaY - currentDeltaY); + } + if (deltaX !== 0 || deltaY !== 0) { + const { modifiers } = keyState; + await __privateGet(this, _context).cdpTarget.cdpClient.sendCommand("Input.dispatchMouseEvent", { + type: "mouseWheel", + deltaX, + deltaY, + x: targetX, + y: targetY, + modifiers + }); + currentDeltaX += deltaX; + currentDeltaY += deltaY; + } + } while (!last); + }; + _dispatchKeyDownAction = new WeakSet(); + dispatchKeyDownAction_fn = async function(source, action) { + const rawKey = action.value; + if (!(0, GraphemeTools_js_1.isSingleGrapheme)(rawKey)) { + throw new protocol_js_1.InvalidArgumentException(`Invalid key value: ${rawKey}`); + } + const isGrapheme = (0, GraphemeTools_js_1.isSingleComplexGrapheme)(rawKey); + const key = (0, keyUtils_js_1.getNormalizedKey)(rawKey); + const repeat = source.pressed.has(key); + const code = (0, keyUtils_js_1.getKeyCode)(rawKey); + const location = (0, keyUtils_js_1.getKeyLocation)(rawKey); + switch (key) { + case "Alt": + source.alt = true; + break; + case "Shift": + source.shift = true; + break; + case "Control": + source.ctrl = true; + break; + case "Meta": + source.meta = true; + break; + } + source.pressed.add(key); + const { modifiers } = source; + const unmodifiedText = getKeyEventUnmodifiedText(key, source, isGrapheme); + const text = getKeyEventText(code ?? "", source) ?? unmodifiedText; + let command; + if (__privateGet(this, _isMacOS) && source.meta) { + switch (code) { + case "KeyA": + command = "SelectAll"; + break; + case "KeyC": + command = "Copy"; + break; + case "KeyV": + command = source.shift ? "PasteAndMatchStyle" : "Paste"; + break; + case "KeyX": + command = "Cut"; + break; + case "KeyZ": + command = source.shift ? "Redo" : "Undo"; + break; + default: + } + } + const promises = [ + __privateGet(this, _context).cdpTarget.cdpClient.sendCommand("Input.dispatchKeyEvent", { + type: text ? "keyDown" : "rawKeyDown", + windowsVirtualKeyCode: USKeyboardLayout_js_1.KeyToKeyCode[key], + key, + code, + text, + unmodifiedText, + autoRepeat: repeat, + isSystemKey: source.alt || void 0, + location: location < 3 ? location : void 0, + isKeypad: location === 3, + modifiers, + commands: command ? [command] : void 0 + }) + ]; + if (key === "Escape") { + if (!source.alt && (__privateGet(this, _isMacOS) && !source.ctrl && !source.meta || !__privateGet(this, _isMacOS))) { + promises.push(__privateGet(this, _context).cdpTarget.cdpClient.sendCommand("Input.cancelDragging")); + } + } + await Promise.all(promises); + }; + _dispatchKeyUpAction = new WeakSet(); + dispatchKeyUpAction_fn = function(source, action) { + const rawKey = action.value; + if (!(0, GraphemeTools_js_1.isSingleGrapheme)(rawKey)) { + throw new protocol_js_1.InvalidArgumentException(`Invalid key value: ${rawKey}`); + } + const isGrapheme = (0, GraphemeTools_js_1.isSingleComplexGrapheme)(rawKey); + const key = (0, keyUtils_js_1.getNormalizedKey)(rawKey); + if (!source.pressed.has(key)) { + return; + } + const code = (0, keyUtils_js_1.getKeyCode)(rawKey); + const location = (0, keyUtils_js_1.getKeyLocation)(rawKey); + switch (key) { + case "Alt": + source.alt = false; + break; + case "Shift": + source.shift = false; + break; + case "Control": + source.ctrl = false; + break; + case "Meta": + source.meta = false; + break; + } + source.pressed.delete(key); + const { modifiers } = source; + const unmodifiedText = getKeyEventUnmodifiedText(key, source, isGrapheme); + const text = getKeyEventText(code ?? "", source) ?? unmodifiedText; + return __privateGet(this, _context).cdpTarget.cdpClient.sendCommand("Input.dispatchKeyEvent", { + type: "keyUp", + windowsVirtualKeyCode: USKeyboardLayout_js_1.KeyToKeyCode[key], + key, + code, + text, + unmodifiedText, + location: location < 3 ? location : void 0, + isSystemKey: source.alt || void 0, + isKeypad: location === 3, + modifiers + }); + }; + __publicField(ActionDispatcher, "isMacOS", async (context) => { + const result = await (await context.getOrCreateSandbox(void 0)).callFunction(IS_MAC_DECL, false); + (0, assert_js_1.assert)(result.type !== "exception"); + (0, assert_js_1.assert)(result.result.type === "boolean"); + return result.result.value; + }); + exports.ActionDispatcher = ActionDispatcher; + var getKeyEventUnmodifiedText = (key, source, isGrapheme) => { + if (isGrapheme) { + return key; + } + if (key === "Enter") { + return "\r"; + } + return [...key].length === 1 ? source.shift ? key.toLocaleUpperCase("en-US") : key : void 0; + }; + var getKeyEventText = (code, source) => { + if (source.ctrl) { + switch (code) { + case "Digit2": + if (source.shift) { + return "\0"; + } + break; + case "KeyA": + return ""; + case "KeyB": + return ""; + case "KeyC": + return ""; + case "KeyD": + return ""; + case "KeyE": + return ""; + case "KeyF": + return ""; + case "KeyG": + return "\x07"; + case "KeyH": + return "\b"; + case "KeyI": + return " "; + case "KeyJ": + return "\n"; + case "KeyK": + return "\v"; + case "KeyL": + return "\f"; + case "KeyM": + return "\r"; + case "KeyN": + return ""; + case "KeyO": + return ""; + case "KeyP": + return ""; + case "KeyQ": + return ""; + case "KeyR": + return ""; + case "KeyS": + return ""; + case "KeyT": + return ""; + case "KeyU": + return ""; + case "KeyV": + return ""; + case "KeyW": + return ""; + case "KeyX": + return ""; + case "KeyY": + return ""; + case "KeyZ": + return ""; + case "BracketLeft": + return "\x1B"; + case "Backslash": + return ""; + case "BracketRight": + return ""; + case "Digit6": + if (source.shift) { + return ""; + } + break; + case "Minus": + return ""; + } + return ""; + } + if (source.alt) { + return ""; + } + return; + }; + function getCdpButton(button) { + switch (button) { + case 0: + return "left"; + case 1: + return "middle"; + case 2: + return "right"; + case 3: + return "back"; + case 4: + return "forward"; + default: + return "none"; + } + } + function getTilt(action) { + const altitudeAngle = action.altitudeAngle ?? Math.PI / 2; + const azimuthAngle = action.azimuthAngle ?? 0; + let tiltXRadians = 0; + let tiltYRadians = 0; + if (altitudeAngle === 0) { + if (azimuthAngle === 0 || azimuthAngle === 2 * Math.PI) { + tiltXRadians = Math.PI / 2; + } + if (azimuthAngle === Math.PI / 2) { + tiltYRadians = Math.PI / 2; + } + if (azimuthAngle === Math.PI) { + tiltXRadians = -Math.PI / 2; + } + if (azimuthAngle === 3 * Math.PI / 2) { + tiltYRadians = -Math.PI / 2; + } + if (azimuthAngle > 0 && azimuthAngle < Math.PI / 2) { + tiltXRadians = Math.PI / 2; + tiltYRadians = Math.PI / 2; + } + if (azimuthAngle > Math.PI / 2 && azimuthAngle < Math.PI) { + tiltXRadians = -Math.PI / 2; + tiltYRadians = Math.PI / 2; + } + if (azimuthAngle > Math.PI && azimuthAngle < 3 * Math.PI / 2) { + tiltXRadians = -Math.PI / 2; + tiltYRadians = -Math.PI / 2; + } + if (azimuthAngle > 3 * Math.PI / 2 && azimuthAngle < 2 * Math.PI) { + tiltXRadians = Math.PI / 2; + tiltYRadians = -Math.PI / 2; + } + } + if (altitudeAngle !== 0) { + const tanAlt = Math.tan(altitudeAngle); + tiltXRadians = Math.atan(Math.cos(azimuthAngle) / tanAlt); + tiltYRadians = Math.atan(Math.sin(azimuthAngle) / tanAlt); + } + const factor = 180 / Math.PI; + return { + tiltX: Math.round(tiltXRadians * factor), + tiltY: Math.round(tiltYRadians * factor) + }; + } + function getRadii(width, height) { + return { + radiusX: width ? width / 2 : 0.5, + radiusY: height ? height / 2 : 0.5 + }; + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/Mutex.js +var require_Mutex = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/Mutex.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Mutex = void 0; + var Mutex = class { + #locked = false; + #acquirers = []; + // This is FIFO. + acquire() { + const state = { resolved: false }; + if (this.#locked) { + return new Promise((resolve) => { + this.#acquirers.push(() => resolve(this.#release.bind(this, state))); + }); + } + this.#locked = true; + return Promise.resolve(this.#release.bind(this, state)); + } + #release(state) { + if (state.resolved) { + throw new Error("Cannot release more than once."); + } + state.resolved = true; + const resolve = this.#acquirers.shift(); + if (!resolve) { + this.#locked = false; + return; + } + resolve(); + } + async run(action) { + const release = await this.acquire(); + try { + const result = await action(); + return result; + } finally { + release(); + } + } + }; + exports.Mutex = Mutex; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/InputState.js +var require_InputState = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/InputState.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.InputState = void 0; + var protocol_js_1 = require_protocol(); + var Mutex_js_1 = require_Mutex(); + var InputSource_js_1 = require_InputSource(); + var InputState = class { + cancelList = []; + #sources = /* @__PURE__ */ new Map(); + #mutex = new Mutex_js_1.Mutex(); + getOrCreate(id, type, subtype) { + let source = this.#sources.get(id); + if (!source) { + switch (type) { + case "none": + source = new InputSource_js_1.NoneSource(); + break; + case "key": + source = new InputSource_js_1.KeySource(); + break; + case "pointer": { + let pointerId = subtype === "mouse" ? 0 : 2; + const pointerIds = /* @__PURE__ */ new Set(); + for (const [, source2] of this.#sources) { + if (source2.type === "pointer") { + pointerIds.add(source2.pointerId); + } + } + while (pointerIds.has(pointerId)) { + ++pointerId; + } + source = new InputSource_js_1.PointerSource(pointerId, subtype); + break; + } + case "wheel": + source = new InputSource_js_1.WheelSource(); + break; + default: + throw new protocol_js_1.InvalidArgumentException(`Expected "${"none"}", "${"key"}", "${"pointer"}", or "${"wheel"}". Found unknown source type ${type}.`); + } + this.#sources.set(id, source); + return source; + } + if (source.type !== type) { + throw new protocol_js_1.InvalidArgumentException(`Input source type of ${id} is ${source.type}, but received ${type}.`); + } + return source; + } + get(id) { + const source = this.#sources.get(id); + if (!source) { + throw new protocol_js_1.UnknownErrorException(`Internal error.`); + } + return source; + } + getGlobalKeyState() { + const state = new InputSource_js_1.KeySource(); + for (const [, source] of this.#sources) { + if (source.type !== "key") { + continue; + } + for (const pressed of source.pressed) { + state.pressed.add(pressed); + } + state.alt ||= source.alt; + state.ctrl ||= source.ctrl; + state.meta ||= source.meta; + state.shift ||= source.shift; + } + return state; + } + get queue() { + return this.#mutex; + } + }; + exports.InputState = InputState; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/InputStateManager.js +var require_InputStateManager = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/InputStateManager.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.InputStateManager = void 0; + var assert_js_1 = require_assert(); + var InputState_js_1 = require_InputState(); + var InputStateManager = class extends WeakMap { + get(context) { + (0, assert_js_1.assert)(context.isTopLevelContext()); + if (!this.has(context)) { + this.set(context, new InputState_js_1.InputState()); + } + return super.get(context); + } + }; + exports.InputStateManager = InputStateManager; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/InputProcessor.js +var require_InputProcessor = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/input/InputProcessor.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.InputProcessor = void 0; + var protocol_js_1 = require_protocol(); + var assert_js_1 = require_assert(); + var ActionDispatcher_js_1 = require_ActionDispatcher(); + var InputStateManager_js_1 = require_InputStateManager(); + var InputProcessor = class { + #browsingContextStorage; + #inputStateManager = new InputStateManager_js_1.InputStateManager(); + constructor(browsingContextStorage) { + this.#browsingContextStorage = browsingContextStorage; + } + async performActions(params) { + const context = this.#browsingContextStorage.getContext(params.context); + const inputState = this.#inputStateManager.get(context.top); + const actionsByTick = this.#getActionsByTick(params, inputState); + const dispatcher = new ActionDispatcher_js_1.ActionDispatcher(inputState, context, await ActionDispatcher_js_1.ActionDispatcher.isMacOS(context).catch(() => false)); + await dispatcher.dispatchActions(actionsByTick); + return {}; + } + async releaseActions(params) { + const context = this.#browsingContextStorage.getContext(params.context); + const topContext = context.top; + const inputState = this.#inputStateManager.get(topContext); + const dispatcher = new ActionDispatcher_js_1.ActionDispatcher(inputState, context, await ActionDispatcher_js_1.ActionDispatcher.isMacOS(context).catch(() => false)); + await dispatcher.dispatchTickActions(inputState.cancelList.reverse()); + this.#inputStateManager.delete(topContext); + return {}; + } + async setFiles(params) { + const context = this.#browsingContextStorage.getContext(params.context); + const realm = await context.getOrCreateSandbox(void 0); + let result; + try { + result = await realm.callFunction(String(function getFiles(fileListLength) { + if (!(this instanceof HTMLInputElement)) { + if (this instanceof Element) { + return 1; + } + return 0; + } + if (this.type !== "file") { + return 2; + } + if (this.disabled) { + return 3; + } + if (fileListLength > 1 && !this.multiple) { + return 4; + } + return; + }), false, params.element, [{ type: "number", value: params.files.length }]); + } catch { + throw new protocol_js_1.NoSuchNodeException(`Could not find element ${params.element.sharedId}`); + } + (0, assert_js_1.assert)(result.type === "success"); + if (result.result.type === "number") { + switch (result.result.value) { + case 0: { + throw new protocol_js_1.NoSuchElementException(`Could not find element ${params.element.sharedId}`); + } + case 1: { + throw new protocol_js_1.UnableToSetFileInputException(`Element ${params.element.sharedId} is not a input`); + } + case 2: { + throw new protocol_js_1.UnableToSetFileInputException(`Input element ${params.element.sharedId} is not a file type`); + } + case 3: { + throw new protocol_js_1.UnableToSetFileInputException(`Input element ${params.element.sharedId} is disabled`); + } + case 4: { + throw new protocol_js_1.UnableToSetFileInputException(`Cannot set multiple files on a non-multiple input element`); + } + } + } + if (params.files.length === 0) { + await realm.callFunction(String(function dispatchEvent() { + if (this.files?.length === 0) { + this.dispatchEvent(new Event("cancel", { + bubbles: true + })); + return; + } + this.files = new DataTransfer().files; + this.dispatchEvent(new Event("input", { bubbles: true, composed: true })); + this.dispatchEvent(new Event("change", { bubbles: true })); + }), false, params.element); + return {}; + } + const paths = []; + for (let i = 0; i < params.files.length; ++i) { + const result2 = await realm.callFunction( + String(function getFiles(index) { + return this.files?.item(index); + }), + false, + params.element, + [{ type: "number", value: 0 }], + "root" + /* Script.ResultOwnership.Root */ + ); + (0, assert_js_1.assert)(result2.type === "success"); + if (result2.result.type !== "object") { + break; + } + const { handle } = result2.result; + (0, assert_js_1.assert)(handle !== void 0); + const { path } = await realm.cdpClient.sendCommand("DOM.getFileInfo", { + objectId: handle + }); + paths.push(path); + void realm.disown(handle).catch(void 0); + } + paths.sort(); + const sortedFiles = [...params.files].sort(); + if (paths.length !== params.files.length || sortedFiles.some((path, index) => { + return paths[index] !== path; + })) { + const { objectId } = await realm.deserializeForCdp(params.element); + (0, assert_js_1.assert)(objectId !== void 0); + await realm.cdpClient.sendCommand("DOM.setFileInputFiles", { + files: params.files, + objectId + }); + } else { + await realm.callFunction(String(function dispatchEvent() { + this.dispatchEvent(new Event("cancel", { + bubbles: true + })); + }), false, params.element); + } + return {}; + } + #getActionsByTick(params, inputState) { + const actionsByTick = []; + for (const action of params.actions) { + switch (action.type) { + case "pointer": { + action.parameters ??= { + pointerType: "mouse" + /* Input.PointerType.Mouse */ + }; + action.parameters.pointerType ??= "mouse"; + const source = inputState.getOrCreate(action.id, "pointer", action.parameters.pointerType); + if (source.subtype !== action.parameters.pointerType) { + throw new protocol_js_1.InvalidArgumentException(`Expected input source ${action.id} to be ${source.subtype}; got ${action.parameters.pointerType}.`); + } + break; + } + default: + inputState.getOrCreate(action.id, action.type); + } + const actions = action.actions.map((item) => ({ + id: action.id, + action: item + })); + for (let i = 0; i < actions.length; i++) { + if (actionsByTick.length === i) { + actionsByTick.push([]); + } + actionsByTick[i].push(actions[i]); + } + } + return actionsByTick; + } + }; + exports.InputProcessor = InputProcessor; + } +}); + +// ../testeranto/node_modules/urlpattern-polyfill/dist/urlpattern.cjs +var require_urlpattern = __commonJS({ + "../testeranto/node_modules/urlpattern-polyfill/dist/urlpattern.cjs"(exports, module) { + "use strict"; + init_cjs_shim(); + var M = Object.defineProperty; + var Pe = Object.getOwnPropertyDescriptor; + var Re = Object.getOwnPropertyNames; + var Ee = Object.prototype.hasOwnProperty; + var Oe = (e, t) => { + for (var r in t) + M(e, r, { get: t[r], enumerable: true }); + }; + var ke = (e, t, r, n) => { + if (t && typeof t == "object" || typeof t == "function") + for (let a of Re(t)) + !Ee.call(e, a) && a !== r && M(e, a, { get: () => t[a], enumerable: !(n = Pe(t, a)) || n.enumerable }); + return e; + }; + var Te = (e) => ke(M({}, "__esModule", { value: true }), e); + var Ne = {}; + Oe(Ne, { URLPattern: () => Y }); + module.exports = Te(Ne); + var R = class { + type = 3; + name = ""; + prefix = ""; + value = ""; + suffix = ""; + modifier = 3; + constructor(t, r, n, a, c, l) { + this.type = t, this.name = r, this.prefix = n, this.value = a, this.suffix = c, this.modifier = l; + } + hasCustomName() { + return this.name !== "" && typeof this.name != "number"; + } + }; + var Ae = /[$_\p{ID_Start}]/u; + var ye = /[$_\u200C\u200D\p{ID_Continue}]/u; + var v = ".*"; + function we(e, t) { + return (t ? /^[\x00-\xFF]*$/ : /^[\x00-\x7F]*$/).test(e); + } + function D(e, t = false) { + let r = [], n = 0; + for (; n < e.length; ) { + let a = e[n], c = function(l) { + if (!t) + throw new TypeError(l); + r.push({ type: "INVALID_CHAR", index: n, value: e[n++] }); + }; + if (a === "*") { + r.push({ type: "ASTERISK", index: n, value: e[n++] }); + continue; + } + if (a === "+" || a === "?") { + r.push({ type: "OTHER_MODIFIER", index: n, value: e[n++] }); + continue; + } + if (a === "\\") { + r.push({ type: "ESCAPED_CHAR", index: n++, value: e[n++] }); + continue; + } + if (a === "{") { + r.push({ type: "OPEN", index: n, value: e[n++] }); + continue; + } + if (a === "}") { + r.push({ type: "CLOSE", index: n, value: e[n++] }); + continue; + } + if (a === ":") { + let l = "", s = n + 1; + for (; s < e.length; ) { + let i = e.substr(s, 1); + if (s === n + 1 && Ae.test(i) || s !== n + 1 && ye.test(i)) { + l += e[s++]; + continue; + } + break; + } + if (!l) { + c(`Missing parameter name at ${n}`); + continue; + } + r.push({ type: "NAME", index: n, value: l }), n = s; + continue; + } + if (a === "(") { + let l = 1, s = "", i = n + 1, o = false; + if (e[i] === "?") { + c(`Pattern cannot start with "?" at ${i}`); + continue; + } + for (; i < e.length; ) { + if (!we(e[i], false)) { + c(`Invalid character '${e[i]}' at ${i}.`), o = true; + break; + } + if (e[i] === "\\") { + s += e[i++] + e[i++]; + continue; + } + if (e[i] === ")") { + if (l--, l === 0) { + i++; + break; + } + } else if (e[i] === "(" && (l++, e[i + 1] !== "?")) { + c(`Capturing groups are not allowed at ${i}`), o = true; + break; + } + s += e[i++]; + } + if (o) + continue; + if (l) { + c(`Unbalanced pattern at ${n}`); + continue; + } + if (!s) { + c(`Missing pattern at ${n}`); + continue; + } + r.push({ type: "REGEX", index: n, value: s }), n = i; + continue; + } + r.push({ type: "CHAR", index: n, value: e[n++] }); + } + return r.push({ type: "END", index: n, value: "" }), r; + } + function F(e, t = {}) { + let r = D(e); + t.delimiter ??= "/#?", t.prefixes ??= "./"; + let n = `[^${S(t.delimiter)}]+?`, a = [], c = 0, l = 0, s = "", i = /* @__PURE__ */ new Set(), o = (h) => { + if (l < r.length && r[l].type === h) + return r[l++].value; + }, f = () => o("OTHER_MODIFIER") ?? o("ASTERISK"), d = (h) => { + let u = o(h); + if (u !== void 0) + return u; + let { type: p, index: A } = r[l]; + throw new TypeError(`Unexpected ${p} at ${A}, expected ${h}`); + }, T = () => { + let h = "", u; + for (; u = o("CHAR") ?? o("ESCAPED_CHAR"); ) + h += u; + return h; + }, xe = (h) => h, L = t.encodePart || xe, I = "", U = (h) => { + I += h; + }, $ = () => { + I.length && (a.push(new R(3, "", "", L(I), "", 3)), I = ""); + }, X = (h, u, p, A, Z) => { + let g = 3; + switch (Z) { + case "?": + g = 1; + break; + case "*": + g = 0; + break; + case "+": + g = 2; + break; + } + if (!u && !p && g === 3) { + U(h); + return; + } + if ($(), !u && !p) { + if (!h) + return; + a.push(new R(3, "", "", L(h), "", g)); + return; + } + let m; + p ? p === "*" ? m = v : m = p : m = n; + let O = 2; + m === n ? (O = 1, m = "") : m === v && (O = 0, m = ""); + let P; + if (u ? P = u : p && (P = c++), i.has(P)) + throw new TypeError(`Duplicate name '${P}'.`); + i.add(P), a.push(new R(O, P, L(h), m, L(A), g)); + }; + for (; l < r.length; ) { + let h = o("CHAR"), u = o("NAME"), p = o("REGEX"); + if (!u && !p && (p = o("ASTERISK")), u || p) { + let g = h ?? ""; + t.prefixes.indexOf(g) === -1 && (U(g), g = ""), $(); + let m = f(); + X(g, u, p, "", m); + continue; + } + let A = h ?? o("ESCAPED_CHAR"); + if (A) { + U(A); + continue; + } + if (o("OPEN")) { + let g = T(), m = o("NAME"), O = o("REGEX"); + !m && !O && (O = o("ASTERISK")); + let P = T(); + d("CLOSE"); + let be = f(); + X(g, m, O, P, be); + continue; + } + $(), d("END"); + } + return a; + } + function S(e) { + return e.replace(/([.+*?^${}()[\]|/\\])/g, "\\$1"); + } + function B(e) { + return e && e.ignoreCase ? "ui" : "u"; + } + function q(e, t, r) { + return W(F(e, r), t, r); + } + function k(e) { + switch (e) { + case 0: + return "*"; + case 1: + return "?"; + case 2: + return "+"; + case 3: + return ""; + } + } + function W(e, t, r = {}) { + r.delimiter ??= "/#?", r.prefixes ??= "./", r.sensitive ??= false, r.strict ??= false, r.end ??= true, r.start ??= true, r.endsWith = ""; + let n = r.start ? "^" : ""; + for (let s of e) { + if (s.type === 3) { + s.modifier === 3 ? n += S(s.value) : n += `(?:${S(s.value)})${k(s.modifier)}`; + continue; + } + t && t.push(s.name); + let i = `[^${S(r.delimiter)}]+?`, o = s.value; + if (s.type === 1 ? o = i : s.type === 0 && (o = v), !s.prefix.length && !s.suffix.length) { + s.modifier === 3 || s.modifier === 1 ? n += `(${o})${k(s.modifier)}` : n += `((?:${o})${k(s.modifier)})`; + continue; + } + if (s.modifier === 3 || s.modifier === 1) { + n += `(?:${S(s.prefix)}(${o})${S(s.suffix)})`, n += k(s.modifier); + continue; + } + n += `(?:${S(s.prefix)}`, n += `((?:${o})(?:`, n += S(s.suffix), n += S(s.prefix), n += `(?:${o}))*)${S(s.suffix)})`, s.modifier === 0 && (n += "?"); + } + let a = `[${S(r.endsWith)}]|$`, c = `[${S(r.delimiter)}]`; + if (r.end) + return r.strict || (n += `${c}?`), r.endsWith.length ? n += `(?=${a})` : n += "$", new RegExp(n, B(r)); + r.strict || (n += `(?:${c}(?=${a}))?`); + let l = false; + if (e.length) { + let s = e[e.length - 1]; + s.type === 3 && s.modifier === 3 && (l = r.delimiter.indexOf(s) > -1); + } + return l || (n += `(?=${c}|${a})`), new RegExp(n, B(r)); + } + var x = { delimiter: "", prefixes: "", sensitive: true, strict: true }; + var J = { delimiter: ".", prefixes: "", sensitive: true, strict: true }; + var Q = { delimiter: "/", prefixes: "/", sensitive: true, strict: true }; + function ee(e, t) { + return e.length ? e[0] === "/" ? true : !t || e.length < 2 ? false : (e[0] == "\\" || e[0] == "{") && e[1] == "/" : false; + } + function te(e, t) { + return e.startsWith(t) ? e.substring(t.length, e.length) : e; + } + function Ce(e, t) { + return e.endsWith(t) ? e.substr(0, e.length - t.length) : e; + } + function _(e) { + return !e || e.length < 2 ? false : e[0] === "[" || (e[0] === "\\" || e[0] === "{") && e[1] === "["; + } + var re = ["ftp", "file", "http", "https", "ws", "wss"]; + function N(e) { + if (!e) + return true; + for (let t of re) + if (e.test(t)) + return true; + return false; + } + function ne(e, t) { + if (e = te(e, "#"), t || e === "") + return e; + let r = new URL("https://example.com"); + return r.hash = e, r.hash ? r.hash.substring(1, r.hash.length) : ""; + } + function se(e, t) { + if (e = te(e, "?"), t || e === "") + return e; + let r = new URL("https://example.com"); + return r.search = e, r.search ? r.search.substring(1, r.search.length) : ""; + } + function ie(e, t) { + return t || e === "" ? e : _(e) ? K(e) : j(e); + } + function ae(e, t) { + if (t || e === "") + return e; + let r = new URL("https://example.com"); + return r.password = e, r.password; + } + function oe(e, t) { + if (t || e === "") + return e; + let r = new URL("https://example.com"); + return r.username = e, r.username; + } + function ce(e, t, r) { + if (r || e === "") + return e; + if (t && !re.includes(t)) + return new URL(`${t}:${e}`).pathname; + let n = e[0] == "/"; + return e = new URL(n ? e : "/-" + e, "https://example.com").pathname, n || (e = e.substring(2, e.length)), e; + } + function le(e, t, r) { + return z(t) === e && (e = ""), r || e === "" ? e : G(e); + } + function fe(e, t) { + return e = Ce(e, ":"), t || e === "" ? e : y(e); + } + function z(e) { + switch (e) { + case "ws": + case "http": + return "80"; + case "wws": + case "https": + return "443"; + case "ftp": + return "21"; + default: + return ""; + } + } + function y(e) { + if (e === "") + return e; + if (/^[-+.A-Za-z0-9]*$/.test(e)) + return e.toLowerCase(); + throw new TypeError(`Invalid protocol '${e}'.`); + } + function he(e) { + if (e === "") + return e; + let t = new URL("https://example.com"); + return t.username = e, t.username; + } + function ue(e) { + if (e === "") + return e; + let t = new URL("https://example.com"); + return t.password = e, t.password; + } + function j(e) { + if (e === "") + return e; + if (/[\t\n\r #%/:<>?@[\]^\\|]/g.test(e)) + throw new TypeError(`Invalid hostname '${e}'`); + let t = new URL("https://example.com"); + return t.hostname = e, t.hostname; + } + function K(e) { + if (e === "") + return e; + if (/[^0-9a-fA-F[\]:]/g.test(e)) + throw new TypeError(`Invalid IPv6 hostname '${e}'`); + return e.toLowerCase(); + } + function G(e) { + if (e === "" || /^[0-9]*$/.test(e) && parseInt(e) <= 65535) + return e; + throw new TypeError(`Invalid port '${e}'.`); + } + function de(e) { + if (e === "") + return e; + let t = new URL("https://example.com"); + return t.pathname = e[0] !== "/" ? "/-" + e : e, e[0] !== "/" ? t.pathname.substring(2, t.pathname.length) : t.pathname; + } + function pe(e) { + return e === "" ? e : new URL(`data:${e}`).pathname; + } + function ge(e) { + if (e === "") + return e; + let t = new URL("https://example.com"); + return t.search = e, t.search.substring(1, t.search.length); + } + function me(e) { + if (e === "") + return e; + let t = new URL("https://example.com"); + return t.hash = e, t.hash.substring(1, t.hash.length); + } + var H = class { + #i; + #n = []; + #t = {}; + #e = 0; + #s = 1; + #l = 0; + #o = 0; + #d = 0; + #p = 0; + #g = false; + constructor(t) { + this.#i = t; + } + get result() { + return this.#t; + } + parse() { + for (this.#n = D(this.#i, true); this.#e < this.#n.length; this.#e += this.#s) { + if (this.#s = 1, this.#n[this.#e].type === "END") { + if (this.#o === 0) { + this.#b(), this.#f() ? this.#r(9, 1) : this.#h() ? this.#r(8, 1) : this.#r(7, 0); + continue; + } else if (this.#o === 2) { + this.#u(5); + continue; + } + this.#r(10, 0); + break; + } + if (this.#d > 0) + if (this.#A()) + this.#d -= 1; + else + continue; + if (this.#T()) { + this.#d += 1; + continue; + } + switch (this.#o) { + case 0: + this.#P() && this.#u(1); + break; + case 1: + if (this.#P()) { + this.#C(); + let t = 7, r = 1; + this.#E() ? (t = 2, r = 3) : this.#g && (t = 2), this.#r(t, r); + } + break; + case 2: + this.#S() ? this.#u(3) : (this.#x() || this.#h() || this.#f()) && this.#u(5); + break; + case 3: + this.#O() ? this.#r(4, 1) : this.#S() && this.#r(5, 1); + break; + case 4: + this.#S() && this.#r(5, 1); + break; + case 5: + this.#y() ? this.#p += 1 : this.#w() && (this.#p -= 1), this.#k() && !this.#p ? this.#r(6, 1) : this.#x() ? this.#r(7, 0) : this.#h() ? this.#r(8, 1) : this.#f() && this.#r(9, 1); + break; + case 6: + this.#x() ? this.#r(7, 0) : this.#h() ? this.#r(8, 1) : this.#f() && this.#r(9, 1); + break; + case 7: + this.#h() ? this.#r(8, 1) : this.#f() && this.#r(9, 1); + break; + case 8: + this.#f() && this.#r(9, 1); + break; + case 9: + break; + case 10: + break; + } + } + this.#t.hostname !== void 0 && this.#t.port === void 0 && (this.#t.port = ""); + } + #r(t, r) { + switch (this.#o) { + case 0: + break; + case 1: + this.#t.protocol = this.#c(); + break; + case 2: + break; + case 3: + this.#t.username = this.#c(); + break; + case 4: + this.#t.password = this.#c(); + break; + case 5: + this.#t.hostname = this.#c(); + break; + case 6: + this.#t.port = this.#c(); + break; + case 7: + this.#t.pathname = this.#c(); + break; + case 8: + this.#t.search = this.#c(); + break; + case 9: + this.#t.hash = this.#c(); + break; + case 10: + break; + } + this.#o !== 0 && t !== 10 && ([1, 2, 3, 4].includes(this.#o) && [6, 7, 8, 9].includes(t) && (this.#t.hostname ??= ""), [1, 2, 3, 4, 5, 6].includes(this.#o) && [8, 9].includes(t) && (this.#t.pathname ??= this.#g ? "/" : ""), [1, 2, 3, 4, 5, 6, 7].includes(this.#o) && t === 9 && (this.#t.search ??= "")), this.#R(t, r); + } + #R(t, r) { + this.#o = t, this.#l = this.#e + r, this.#e += r, this.#s = 0; + } + #b() { + this.#e = this.#l, this.#s = 0; + } + #u(t) { + this.#b(), this.#o = t; + } + #m(t) { + return t < 0 && (t = this.#n.length - t), t < this.#n.length ? this.#n[t] : this.#n[this.#n.length - 1]; + } + #a(t, r) { + let n = this.#m(t); + return n.value === r && (n.type === "CHAR" || n.type === "ESCAPED_CHAR" || n.type === "INVALID_CHAR"); + } + #P() { + return this.#a(this.#e, ":"); + } + #E() { + return this.#a(this.#e + 1, "/") && this.#a(this.#e + 2, "/"); + } + #S() { + return this.#a(this.#e, "@"); + } + #O() { + return this.#a(this.#e, ":"); + } + #k() { + return this.#a(this.#e, ":"); + } + #x() { + return this.#a(this.#e, "/"); + } + #h() { + if (this.#a(this.#e, "?")) + return true; + if (this.#n[this.#e].value !== "?") + return false; + let t = this.#m(this.#e - 1); + return t.type !== "NAME" && t.type !== "REGEX" && t.type !== "CLOSE" && t.type !== "ASTERISK"; + } + #f() { + return this.#a(this.#e, "#"); + } + #T() { + return this.#n[this.#e].type == "OPEN"; + } + #A() { + return this.#n[this.#e].type == "CLOSE"; + } + #y() { + return this.#a(this.#e, "["); + } + #w() { + return this.#a(this.#e, "]"); + } + #c() { + let t = this.#n[this.#e], r = this.#m(this.#l).index; + return this.#i.substring(r, t.index); + } + #C() { + let t = {}; + Object.assign(t, x), t.encodePart = y; + let r = q(this.#c(), void 0, t); + this.#g = N(r); + } + }; + var V = ["protocol", "username", "password", "hostname", "port", "pathname", "search", "hash"]; + var E = "*"; + function Se(e, t) { + if (typeof e != "string") + throw new TypeError("parameter 1 is not of type 'string'."); + let r = new URL(e, t); + return { protocol: r.protocol.substring(0, r.protocol.length - 1), username: r.username, password: r.password, hostname: r.hostname, port: r.port, pathname: r.pathname, search: r.search !== "" ? r.search.substring(1, r.search.length) : void 0, hash: r.hash !== "" ? r.hash.substring(1, r.hash.length) : void 0 }; + } + function b(e, t) { + return t ? C(e) : e; + } + function w(e, t, r) { + let n; + if (typeof t.baseURL == "string") + try { + n = new URL(t.baseURL), t.protocol === void 0 && (e.protocol = b(n.protocol.substring(0, n.protocol.length - 1), r)), !r && t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.username === void 0 && (e.username = b(n.username, r)), !r && t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.username === void 0 && t.password === void 0 && (e.password = b(n.password, r)), t.protocol === void 0 && t.hostname === void 0 && (e.hostname = b(n.hostname, r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && (e.port = b(n.port, r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.pathname === void 0 && (e.pathname = b(n.pathname, r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.pathname === void 0 && t.search === void 0 && (e.search = b(n.search.substring(1, n.search.length), r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.pathname === void 0 && t.search === void 0 && t.hash === void 0 && (e.hash = b(n.hash.substring(1, n.hash.length), r)); + } catch { + throw new TypeError(`invalid baseURL '${t.baseURL}'.`); + } + if (typeof t.protocol == "string" && (e.protocol = fe(t.protocol, r)), typeof t.username == "string" && (e.username = oe(t.username, r)), typeof t.password == "string" && (e.password = ae(t.password, r)), typeof t.hostname == "string" && (e.hostname = ie(t.hostname, r)), typeof t.port == "string" && (e.port = le(t.port, e.protocol, r)), typeof t.pathname == "string") { + if (e.pathname = t.pathname, n && !ee(e.pathname, r)) { + let a = n.pathname.lastIndexOf("/"); + a >= 0 && (e.pathname = b(n.pathname.substring(0, a + 1), r) + e.pathname); + } + e.pathname = ce(e.pathname, e.protocol, r); + } + return typeof t.search == "string" && (e.search = se(t.search, r)), typeof t.hash == "string" && (e.hash = ne(t.hash, r)), e; + } + function C(e) { + return e.replace(/([+*?:{}()\\])/g, "\\$1"); + } + function Le(e) { + return e.replace(/([.+*?^${}()[\]|/\\])/g, "\\$1"); + } + function Ie(e, t) { + t.delimiter ??= "/#?", t.prefixes ??= "./", t.sensitive ??= false, t.strict ??= false, t.end ??= true, t.start ??= true, t.endsWith = ""; + let r = ".*", n = `[^${Le(t.delimiter)}]+?`, a = /[$_\u200C\u200D\p{ID_Continue}]/u, c = ""; + for (let l = 0; l < e.length; ++l) { + let s = e[l]; + if (s.type === 3) { + if (s.modifier === 3) { + c += C(s.value); + continue; + } + c += `{${C(s.value)}}${k(s.modifier)}`; + continue; + } + let i = s.hasCustomName(), o = !!s.suffix.length || !!s.prefix.length && (s.prefix.length !== 1 || !t.prefixes.includes(s.prefix)), f = l > 0 ? e[l - 1] : null, d = l < e.length - 1 ? e[l + 1] : null; + if (!o && i && s.type === 1 && s.modifier === 3 && d && !d.prefix.length && !d.suffix.length) + if (d.type === 3) { + let T = d.value.length > 0 ? d.value[0] : ""; + o = a.test(T); + } else + o = !d.hasCustomName(); + if (!o && !s.prefix.length && f && f.type === 3) { + let T = f.value[f.value.length - 1]; + o = t.prefixes.includes(T); + } + o && (c += "{"), c += C(s.prefix), i && (c += `:${s.name}`), s.type === 2 ? c += `(${s.value})` : s.type === 1 ? i || (c += `(${n})`) : s.type === 0 && (!i && (!f || f.type === 3 || f.modifier !== 3 || o || s.prefix !== "") ? c += "*" : c += `(${r})`), s.type === 1 && i && s.suffix.length && a.test(s.suffix[0]) && (c += "\\"), c += C(s.suffix), o && (c += "}"), s.modifier !== 3 && (c += k(s.modifier)); + } + return c; + } + var Y = class { + #i; + #n = {}; + #t = {}; + #e = {}; + #s = {}; + #l = false; + constructor(t = {}, r, n) { + try { + let a; + if (typeof r == "string" ? a = r : n = r, typeof t == "string") { + let i = new H(t); + if (i.parse(), t = i.result, a === void 0 && typeof t.protocol != "string") + throw new TypeError("A base URL must be provided for a relative constructor string."); + t.baseURL = a; + } else { + if (!t || typeof t != "object") + throw new TypeError("parameter 1 is not of type 'string' and cannot convert to dictionary."); + if (a) + throw new TypeError("parameter 1 is not of type 'string'."); + } + typeof n > "u" && (n = { ignoreCase: false }); + let c = { ignoreCase: n.ignoreCase === true }, l = { pathname: E, protocol: E, username: E, password: E, hostname: E, port: E, search: E, hash: E }; + this.#i = w(l, t, true), z(this.#i.protocol) === this.#i.port && (this.#i.port = ""); + let s; + for (s of V) { + if (!(s in this.#i)) + continue; + let i = {}, o = this.#i[s]; + switch (this.#t[s] = [], s) { + case "protocol": + Object.assign(i, x), i.encodePart = y; + break; + case "username": + Object.assign(i, x), i.encodePart = he; + break; + case "password": + Object.assign(i, x), i.encodePart = ue; + break; + case "hostname": + Object.assign(i, J), _(o) ? i.encodePart = K : i.encodePart = j; + break; + case "port": + Object.assign(i, x), i.encodePart = G; + break; + case "pathname": + N(this.#n.protocol) ? (Object.assign(i, Q, c), i.encodePart = de) : (Object.assign(i, x, c), i.encodePart = pe); + break; + case "search": + Object.assign(i, x, c), i.encodePart = ge; + break; + case "hash": + Object.assign(i, x, c), i.encodePart = me; + break; + } + try { + this.#s[s] = F(o, i), this.#n[s] = W(this.#s[s], this.#t[s], i), this.#e[s] = Ie(this.#s[s], i), this.#l = this.#l || this.#s[s].some((f) => f.type === 2); + } catch { + throw new TypeError(`invalid ${s} pattern '${this.#i[s]}'.`); + } + } + } catch (a) { + throw new TypeError(`Failed to construct 'URLPattern': ${a.message}`); + } + } + test(t = {}, r) { + let n = { pathname: "", protocol: "", username: "", password: "", hostname: "", port: "", search: "", hash: "" }; + if (typeof t != "string" && r) + throw new TypeError("parameter 1 is not of type 'string'."); + if (typeof t > "u") + return false; + try { + typeof t == "object" ? n = w(n, t, false) : n = w(n, Se(t, r), false); + } catch { + return false; + } + let a; + for (a of V) + if (!this.#n[a].exec(n[a])) + return false; + return true; + } + exec(t = {}, r) { + let n = { pathname: "", protocol: "", username: "", password: "", hostname: "", port: "", search: "", hash: "" }; + if (typeof t != "string" && r) + throw new TypeError("parameter 1 is not of type 'string'."); + if (typeof t > "u") + return; + try { + typeof t == "object" ? n = w(n, t, false) : n = w(n, Se(t, r), false); + } catch { + return null; + } + let a = {}; + r ? a.inputs = [t, r] : a.inputs = [t]; + let c; + for (c of V) { + let l = this.#n[c].exec(n[c]); + if (!l) + return null; + let s = {}; + for (let [i, o] of this.#t[c].entries()) + if (typeof o == "string" || typeof o == "number") { + let f = l[i + 1]; + s[o] = f; + } + a[c] = { input: n[c] ?? "", groups: s }; + } + return a; + } + static compareComponent(t, r, n) { + let a = (i, o) => { + for (let f of ["type", "modifier", "prefix", "value", "suffix"]) { + if (i[f] < o[f]) + return -1; + if (i[f] === o[f]) + continue; + return 1; + } + return 0; + }, c = new R(3, "", "", "", "", 3), l = new R(0, "", "", "", "", 3), s = (i, o) => { + let f = 0; + for (; f < Math.min(i.length, o.length); ++f) { + let d = a(i[f], o[f]); + if (d) + return d; + } + return i.length === o.length ? 0 : a(i[f] ?? c, o[f] ?? c); + }; + return !r.#e[t] && !n.#e[t] ? 0 : r.#e[t] && !n.#e[t] ? s(r.#s[t], [l]) : !r.#e[t] && n.#e[t] ? s([l], n.#s[t]) : s(r.#s[t], n.#s[t]); + } + get protocol() { + return this.#e.protocol; + } + get username() { + return this.#e.username; + } + get password() { + return this.#e.password; + } + get hostname() { + return this.#e.hostname; + } + get port() { + return this.#e.port; + } + get pathname() { + return this.#e.pathname; + } + get search() { + return this.#e.search; + } + get hash() { + return this.#e.hash; + } + get hasRegExpGroups() { + return this.#l; + } + }; + } +}); + +// ../testeranto/node_modules/urlpattern-polyfill/index.cjs +var require_urlpattern_polyfill = __commonJS({ + "../testeranto/node_modules/urlpattern-polyfill/index.cjs"(exports, module) { + init_cjs_shim(); + var { URLPattern } = require_urlpattern(); + module.exports = { URLPattern }; + if (!globalThis.URLPattern) { + globalThis.URLPattern = URLPattern; + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/UrlPattern.js +var require_UrlPattern = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/UrlPattern.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.URLPattern = void 0; + var urlpattern_polyfill_1 = require_urlpattern_polyfill(); + var URLPattern = urlpattern_polyfill_1.URLPattern; + exports.URLPattern = URLPattern; + if ("URLPattern" in globalThis) { + exports.URLPattern = URLPattern = globalThis.URLPattern; + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/network/NetworkProcessor.js +var require_NetworkProcessor = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/network/NetworkProcessor.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.NetworkProcessor = void 0; + var protocol_js_1 = require_protocol(); + var UrlPattern_js_1 = require_UrlPattern(); + var NetworkProcessor = class { + #browsingContextStorage; + #networkStorage; + constructor(browsingContextStorage, networkStorage) { + this.#browsingContextStorage = browsingContextStorage; + this.#networkStorage = networkStorage; + } + async addIntercept(params) { + this.#browsingContextStorage.verifyTopLevelContextsList(params.contexts); + const urlPatterns = params.urlPatterns ?? []; + const parsedUrlPatterns = NetworkProcessor.parseUrlPatterns(urlPatterns); + const intercept = this.#networkStorage.addIntercept({ + urlPatterns: parsedUrlPatterns, + phases: params.phases, + contexts: params.contexts + }); + await Promise.all(this.#browsingContextStorage.getAllContexts().map((context) => { + return context.cdpTarget.toggleFetchIfNeeded(); + })); + return { + intercept + }; + } + async continueRequest(params) { + if (params.url !== void 0) { + NetworkProcessor.parseUrlString(params.url); + } + if (params.method !== void 0) { + if (!NetworkProcessor.isMethodValid(params.method)) { + throw new protocol_js_1.InvalidArgumentException(`Method '${params.method}' is invalid.`); + } + } + if (params.headers) { + NetworkProcessor.validateHeaders(params.headers); + } + const request = this.#getBlockedRequestOrFail(params.request, [ + "beforeRequestSent" + ]); + try { + await request.continueRequest(params); + } catch (error) { + throw NetworkProcessor.wrapInterceptionError(error); + } + return {}; + } + async continueResponse(params) { + if (params.headers) { + NetworkProcessor.validateHeaders(params.headers); + } + const request = this.#getBlockedRequestOrFail(params.request, [ + "authRequired", + "responseStarted" + ]); + try { + await request.continueResponse(params); + } catch (error) { + throw NetworkProcessor.wrapInterceptionError(error); + } + return {}; + } + async continueWithAuth(params) { + const networkId = params.request; + const request = this.#getBlockedRequestOrFail(networkId, [ + "authRequired" + ]); + await request.continueWithAuth(params); + return {}; + } + async failRequest({ request: networkId }) { + const request = this.#getRequestOrFail(networkId); + if (request.interceptPhase === "authRequired") { + throw new protocol_js_1.InvalidArgumentException(`Request '${networkId}' in 'authRequired' phase cannot be failed`); + } + if (!request.interceptPhase) { + throw new protocol_js_1.NoSuchRequestException(`No blocked request found for network id '${networkId}'`); + } + await request.failRequest("Failed"); + return {}; + } + async provideResponse(params) { + if (params.headers) { + NetworkProcessor.validateHeaders(params.headers); + } + const request = this.#getBlockedRequestOrFail(params.request, [ + "beforeRequestSent", + "responseStarted", + "authRequired" + ]); + try { + await request.provideResponse(params); + } catch (error) { + throw NetworkProcessor.wrapInterceptionError(error); + } + return {}; + } + async removeIntercept(params) { + this.#networkStorage.removeIntercept(params.intercept); + await Promise.all(this.#browsingContextStorage.getAllContexts().map((context) => { + return context.cdpTarget.toggleFetchIfNeeded(); + })); + return {}; + } + async setCacheBehavior(params) { + const contexts = this.#browsingContextStorage.verifyTopLevelContextsList(params.contexts); + if (contexts.size === 0) { + this.#networkStorage.defaultCacheBehavior = params.cacheBehavior; + await Promise.all(this.#browsingContextStorage.getAllContexts().map((context) => { + return context.cdpTarget.toggleSetCacheDisabled(); + })); + return {}; + } + const cacheDisabled = params.cacheBehavior === "bypass"; + await Promise.all([...contexts.values()].map((context) => { + return context.cdpTarget.toggleSetCacheDisabled(cacheDisabled); + })); + return {}; + } + #getRequestOrFail(id) { + const request = this.#networkStorage.getRequestById(id); + if (!request) { + throw new protocol_js_1.NoSuchRequestException(`Network request with ID '${id}' doesn't exist`); + } + return request; + } + #getBlockedRequestOrFail(id, phases) { + const request = this.#getRequestOrFail(id); + if (!request.interceptPhase) { + throw new protocol_js_1.NoSuchRequestException(`No blocked request found for network id '${id}'`); + } + if (request.interceptPhase && !phases.includes(request.interceptPhase)) { + throw new protocol_js_1.InvalidArgumentException(`Blocked request for network id '${id}' is in '${request.interceptPhase}' phase`); + } + return request; + } + /** + * Validate https://fetch.spec.whatwg.org/#header-value + */ + static validateHeaders(headers) { + for (const header of headers) { + let headerValue; + if (header.value.type === "string") { + headerValue = header.value.value; + } else { + headerValue = atob(header.value.value); + } + if (headerValue !== headerValue.trim() || headerValue.includes("\n") || headerValue.includes("\0")) { + throw new protocol_js_1.InvalidArgumentException(`Header value '${headerValue}' is not acceptable value`); + } + } + } + static isMethodValid(method) { + return /^[!#$%&'*+\-.^_`|~a-zA-Z\d]+$/.test(method); + } + /** + * Attempts to parse the given url. + * Throws an InvalidArgumentException if the url is invalid. + */ + static parseUrlString(url) { + try { + return new URL(url); + } catch (error) { + throw new protocol_js_1.InvalidArgumentException(`Invalid URL '${url}': ${error}`); + } + } + static parseUrlPatterns(urlPatterns) { + return urlPatterns.map((urlPattern) => { + switch (urlPattern.type) { + case "string": { + NetworkProcessor.parseUrlString(urlPattern.pattern); + return urlPattern; + } + case "pattern": + if (urlPattern.protocol === void 0 && urlPattern.hostname === void 0 && urlPattern.port === void 0 && urlPattern.pathname === void 0 && urlPattern.search === void 0) { + return urlPattern; + } + if (urlPattern.protocol) { + urlPattern.protocol = unescapeURLPattern(urlPattern.protocol); + if (!urlPattern.protocol.match(/^[a-zA-Z+-.]+$/)) { + throw new protocol_js_1.InvalidArgumentException("Forbidden characters"); + } + } + if (urlPattern.hostname) { + urlPattern.hostname = unescapeURLPattern(urlPattern.hostname); + } + if (urlPattern.port) { + urlPattern.port = unescapeURLPattern(urlPattern.port); + } + if (urlPattern.pathname) { + urlPattern.pathname = unescapeURLPattern(urlPattern.pathname); + if (urlPattern.pathname[0] !== "/") { + urlPattern.pathname = `/${urlPattern.pathname}`; + } + if (urlPattern.pathname.includes("#") || urlPattern.pathname.includes("?")) { + throw new protocol_js_1.InvalidArgumentException("Forbidden characters"); + } + } else if (urlPattern.pathname === "") { + urlPattern.pathname = "/"; + } + if (urlPattern.search) { + urlPattern.search = unescapeURLPattern(urlPattern.search); + if (urlPattern.search[0] !== "?") { + urlPattern.search = `?${urlPattern.search}`; + } + if (urlPattern.search.includes("#")) { + throw new protocol_js_1.InvalidArgumentException("Forbidden characters"); + } + } + if (urlPattern.protocol === "") { + throw new protocol_js_1.InvalidArgumentException(`URL pattern must specify a protocol`); + } + if (urlPattern.hostname === "") { + throw new protocol_js_1.InvalidArgumentException(`URL pattern must specify a hostname`); + } + if ((urlPattern.hostname?.length ?? 0) > 0) { + if (urlPattern.protocol?.match(/^file/i)) { + throw new protocol_js_1.InvalidArgumentException(`URL pattern protocol cannot be 'file'`); + } + if (urlPattern.hostname?.includes(":")) { + throw new protocol_js_1.InvalidArgumentException(`URL pattern hostname must not contain a colon`); + } + } + if (urlPattern.port === "") { + throw new protocol_js_1.InvalidArgumentException(`URL pattern must specify a port`); + } + try { + new UrlPattern_js_1.URLPattern(urlPattern); + } catch (error) { + throw new protocol_js_1.InvalidArgumentException(`${error}`); + } + return urlPattern; + } + }); + } + static wrapInterceptionError(error) { + if (error?.message.includes("Invalid header")) { + return new protocol_js_1.InvalidArgumentException("Invalid header"); + } + return error; + } + }; + exports.NetworkProcessor = NetworkProcessor; + function unescapeURLPattern(pattern) { + const forbidden = /* @__PURE__ */ new Set(["(", ")", "*", "{", "}"]); + let result = ""; + let isEscaped = false; + for (const c of pattern) { + if (!isEscaped) { + if (forbidden.has(c)) { + throw new protocol_js_1.InvalidArgumentException("Forbidden characters"); + } + if (c === "\\") { + isEscaped = true; + continue; + } + } + result += c; + isEscaped = false; + } + return result; + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/permissions/PermissionsProcessor.js +var require_PermissionsProcessor = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/permissions/PermissionsProcessor.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.PermissionsProcessor = void 0; + var protocol_js_1 = require_protocol(); + var PermissionsProcessor = class { + #browserCdpClient; + constructor(browserCdpClient) { + this.#browserCdpClient = browserCdpClient; + } + async setPermissions(params) { + try { + const userContextId = params["goog:userContext"] || params.userContext; + await this.#browserCdpClient.sendCommand("Browser.setPermission", { + origin: params.origin, + browserContextId: userContextId && userContextId !== "default" ? userContextId : void 0, + permission: { + name: params.descriptor.name + }, + setting: params.state + }); + } catch (err) { + if (err.message === `Permission can't be granted to opaque origins.`) { + return {}; + } + throw new protocol_js_1.InvalidArgumentException(err.message); + } + return {}; + } + }; + exports.PermissionsProcessor = PermissionsProcessor; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/uuid.js +var require_uuid = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/uuid.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.uuidv4 = uuidv4; + function bytesToHex(bytes) { + return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), ""); + } + function uuidv4() { + if ("crypto" in globalThis && "randomUUID" in globalThis.crypto) { + return globalThis.crypto.randomUUID(); + } + const randomValues = new Uint8Array(16); + if ("crypto" in globalThis && "getRandomValues" in globalThis.crypto) { + globalThis.crypto.getRandomValues(randomValues); + } else { + __require("crypto").webcrypto.getRandomValues(randomValues); + } + randomValues[6] = randomValues[6] & 15 | 64; + randomValues[8] = randomValues[8] & 63 | 128; + return [ + bytesToHex(randomValues.subarray(0, 4)), + bytesToHex(randomValues.subarray(4, 6)), + bytesToHex(randomValues.subarray(6, 8)), + bytesToHex(randomValues.subarray(8, 10)), + bytesToHex(randomValues.subarray(10, 16)) + ].join("-"); + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/ChannelProxy.js +var require_ChannelProxy = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/ChannelProxy.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ChannelProxy = void 0; + var protocol_js_1 = require_protocol(); + var log_js_1 = require_log(); + var uuid_js_1 = require_uuid(); + var _properties, _id, _logger, _createChannelProxyEvalStr, createChannelProxyEvalStr_fn, _createAndGetHandleInRealm, createAndGetHandleInRealm_fn, _createSendMessageHandle, createSendMessageHandle_fn, _startListener, startListener_fn, _getHandleFromWindow, getHandleFromWindow_fn; + var _ChannelProxy = class { + constructor(channel, logger) { + /** Starts listening for the channel events of the provided ChannelProxy. */ + __privateAdd(this, _startListener); + /** + * Returns a handle of ChannelProxy from window's property which was set there + * by `getEvalInWindowStr`. If window property is not set yet, sets a promise + * resolver to the window property, so that `getEvalInWindowStr` can resolve + * the promise later on with the channel. + * This is needed because `getEvalInWindowStr` can be called before or + * after this method. + */ + __privateAdd(this, _getHandleFromWindow); + __privateAdd(this, _properties, void 0); + __privateAdd(this, _id, (0, uuid_js_1.uuidv4)()); + __privateAdd(this, _logger, void 0); + __privateSet(this, _properties, channel); + __privateSet(this, _logger, logger); + } + /** + * Creates a channel proxy in the given realm, initialises listener and + * returns a handle to `sendMessage` delegate. + */ + async init(realm, eventManager) { + var _a3, _b; + const channelHandle = await __privateMethod(_a3 = _ChannelProxy, _createAndGetHandleInRealm, createAndGetHandleInRealm_fn).call(_a3, realm); + const sendMessageHandle = await __privateMethod(_b = _ChannelProxy, _createSendMessageHandle, createSendMessageHandle_fn).call(_b, realm, channelHandle); + void __privateMethod(this, _startListener, startListener_fn).call(this, realm, channelHandle, eventManager); + return sendMessageHandle; + } + /** Gets a ChannelProxy from window and returns its handle. */ + async startListenerFromWindow(realm, eventManager) { + var _a3; + try { + const channelHandle = await __privateMethod(this, _getHandleFromWindow, getHandleFromWindow_fn).call(this, realm); + void __privateMethod(this, _startListener, startListener_fn).call(this, realm, channelHandle, eventManager); + } catch (error) { + (_a3 = __privateGet(this, _logger)) == null ? void 0 : _a3.call(this, log_js_1.LogType.debugError, error); + } + } + /** + * String to be evaluated to create a ProxyChannel and put it to window. + * Returns the delegate `sendMessage`. Used to provide an argument for preload + * script. Does the following: + * 1. Creates a ChannelProxy. + * 2. Puts the ChannelProxy to window['${this.#id}'] or resolves the promise + * by calling delegate stored in window['${this.#id}']. + * This is needed because `#getHandleFromWindow` can be called before or + * after this method. + * 3. Returns the delegate `sendMessage` of the created ChannelProxy. + */ + getEvalInWindowStr() { + var _a3; + const delegate = String((id, channelProxy) => { + const w = window; + if (w[id] === void 0) { + w[id] = channelProxy; + } else { + w[id](channelProxy); + delete w[id]; + } + return channelProxy.sendMessage; + }); + const channelProxyEval = __privateMethod(_a3 = _ChannelProxy, _createChannelProxyEvalStr, createChannelProxyEvalStr_fn).call(_a3); + return `(${delegate})('${__privateGet(this, _id)}',${channelProxyEval})`; + } + }; + var ChannelProxy = _ChannelProxy; + _properties = new WeakMap(); + _id = new WeakMap(); + _logger = new WeakMap(); + _createChannelProxyEvalStr = new WeakSet(); + createChannelProxyEvalStr_fn = function() { + const functionStr = String(() => { + const queue = []; + let queueNonEmptyResolver = null; + return { + /** + * Gets a promise, which is resolved as soon as a message occurs + * in the queue. + */ + async getMessage() { + const onMessage = queue.length > 0 ? Promise.resolve() : new Promise((resolve) => { + queueNonEmptyResolver = resolve; + }); + await onMessage; + return queue.shift(); + }, + /** + * Adds a message to the queue. + * Resolves the pending promise if needed. + */ + sendMessage(message) { + queue.push(message); + if (queueNonEmptyResolver !== null) { + queueNonEmptyResolver(); + queueNonEmptyResolver = null; + } + } + }; + }); + return `(${functionStr})()`; + }; + _createAndGetHandleInRealm = new WeakSet(); + createAndGetHandleInRealm_fn = async function(realm) { + const createChannelHandleResult = await realm.cdpClient.sendCommand("Runtime.evaluate", { + expression: __privateMethod(this, _createChannelProxyEvalStr, createChannelProxyEvalStr_fn).call(this), + contextId: realm.executionContextId, + serializationOptions: { + serialization: "idOnly" + } + }); + if (createChannelHandleResult.exceptionDetails || createChannelHandleResult.result.objectId === void 0) { + throw new Error(`Cannot create channel`); + } + return createChannelHandleResult.result.objectId; + }; + _createSendMessageHandle = new WeakSet(); + createSendMessageHandle_fn = async function(realm, channelHandle) { + const sendMessageArgResult = await realm.cdpClient.sendCommand("Runtime.callFunctionOn", { + functionDeclaration: String((channelHandle2) => { + return channelHandle2.sendMessage; + }), + arguments: [{ objectId: channelHandle }], + executionContextId: realm.executionContextId, + serializationOptions: { + serialization: "idOnly" + } + }); + return sendMessageArgResult.result.objectId; + }; + _startListener = new WeakSet(); + startListener_fn = async function(realm, channelHandle, eventManager) { + var _a3; + for (; ; ) { + try { + const message = await realm.cdpClient.sendCommand("Runtime.callFunctionOn", { + functionDeclaration: String(async (channelHandle2) => await channelHandle2.getMessage()), + arguments: [ + { + objectId: channelHandle + } + ], + awaitPromise: true, + executionContextId: realm.executionContextId, + serializationOptions: { + serialization: "deep", + maxDepth: __privateGet(this, _properties).serializationOptions?.maxObjectDepth ?? void 0 + } + }); + if (message.exceptionDetails) { + throw new Error("Runtime.callFunctionOn in ChannelProxy", { + cause: message.exceptionDetails + }); + } + for (const browsingContext of realm.associatedBrowsingContexts) { + eventManager.registerEvent({ + type: "event", + method: protocol_js_1.ChromiumBidi.Script.EventNames.Message, + params: { + channel: __privateGet(this, _properties).channel, + data: realm.cdpToBidiValue( + message, + __privateGet(this, _properties).ownership ?? "none" + /* Script.ResultOwnership.None */ + ), + source: realm.source + } + }, browsingContext.id); + } + } catch (error) { + (_a3 = __privateGet(this, _logger)) == null ? void 0 : _a3.call(this, log_js_1.LogType.debugError, error); + break; + } + } + }; + _getHandleFromWindow = new WeakSet(); + getHandleFromWindow_fn = async function(realm) { + const channelHandleResult = await realm.cdpClient.sendCommand("Runtime.callFunctionOn", { + functionDeclaration: String((id) => { + const w = window; + if (w[id] === void 0) { + return new Promise((resolve) => w[id] = resolve); + } + const channelProxy = w[id]; + delete w[id]; + return channelProxy; + }), + arguments: [{ value: __privateGet(this, _id) }], + executionContextId: realm.executionContextId, + awaitPromise: true, + serializationOptions: { + serialization: "idOnly" + } + }); + if (channelHandleResult.exceptionDetails !== void 0 || channelHandleResult.result.objectId === void 0) { + throw new Error(`ChannelHandle not found in window["${__privateGet(this, _id)}"]`); + } + return channelHandleResult.result.objectId; + }; + /** + * Evaluation string which creates a ChannelProxy object on the client side. + */ + __privateAdd(ChannelProxy, _createChannelProxyEvalStr); + /** Creates a ChannelProxy in the given realm. */ + __privateAdd(ChannelProxy, _createAndGetHandleInRealm); + /** Gets a handle to `sendMessage` delegate from the ChannelProxy handle. */ + __privateAdd(ChannelProxy, _createSendMessageHandle); + exports.ChannelProxy = ChannelProxy; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/PreloadScript.js +var require_PreloadScript = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/PreloadScript.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.PreloadScript = void 0; + var uuid_js_1 = require_uuid(); + var ChannelProxy_js_1 = require_ChannelProxy(); + var PreloadScript = class { + /** BiDi ID, an automatically generated UUID. */ + #id = (0, uuid_js_1.uuidv4)(); + /** CDP preload scripts. */ + #cdpPreloadScripts = []; + /** The script itself, in a format expected by the spec i.e. a function. */ + #functionDeclaration; + /** Targets, in which the preload script is initialized. */ + #targetIds = /* @__PURE__ */ new Set(); + /** Channels to be added as arguments to functionDeclaration. */ + #channels; + /** The script sandbox / world name. */ + #sandbox; + /** The browsing contexts to execute the preload scripts in, if any. */ + #contexts; + get id() { + return this.#id; + } + get targetIds() { + return this.#targetIds; + } + constructor(params, logger) { + this.#channels = params.arguments?.map((a) => new ChannelProxy_js_1.ChannelProxy(a.value, logger)) ?? []; + this.#functionDeclaration = params.functionDeclaration; + this.#sandbox = params.sandbox; + this.#contexts = params.contexts; + } + /** Channels of the preload script. */ + get channels() { + return this.#channels; + } + /** Contexts of the preload script, if any */ + get contexts() { + return this.#contexts; + } + /** + * String to be evaluated. Wraps user-provided function so that the following + * steps are run: + * 1. Create channels. + * 2. Store the created channels in window. + * 3. Call the user-provided function with channels as arguments. + */ + #getEvaluateString() { + const channelsArgStr = `[${this.channels.map((c) => c.getEvalInWindowStr()).join(", ")}]`; + return `(()=>{(${this.#functionDeclaration})(...${channelsArgStr})})()`; + } + /** + * Adds the script to the given CDP targets by calling the + * `Page.addScriptToEvaluateOnNewDocument` command. + */ + async initInTargets(cdpTargets, runImmediately) { + await Promise.all(Array.from(cdpTargets).map((cdpTarget) => this.initInTarget(cdpTarget, runImmediately))); + } + /** + * Adds the script to the given CDP target by calling the + * `Page.addScriptToEvaluateOnNewDocument` command. + */ + async initInTarget(cdpTarget, runImmediately) { + const addCdpPreloadScriptResult = await cdpTarget.cdpClient.sendCommand("Page.addScriptToEvaluateOnNewDocument", { + source: this.#getEvaluateString(), + worldName: this.#sandbox, + runImmediately + }); + this.#cdpPreloadScripts.push({ + target: cdpTarget, + preloadScriptId: addCdpPreloadScriptResult.identifier + }); + this.#targetIds.add(cdpTarget.id); + } + /** + * Removes this script from all CDP targets. + */ + async remove() { + await Promise.all([ + this.#cdpPreloadScripts.map(async (cdpPreloadScript) => { + const cdpTarget = cdpPreloadScript.target; + const cdpPreloadScriptId = cdpPreloadScript.preloadScriptId; + return await cdpTarget.cdpClient.sendCommand("Page.removeScriptToEvaluateOnNewDocument", { + identifier: cdpPreloadScriptId + }); + }) + ]); + } + /** Removes the provided cdp target from the list of cdp preload scripts. */ + dispose(cdpTargetId) { + this.#cdpPreloadScripts = this.#cdpPreloadScripts.filter((cdpPreloadScript) => cdpPreloadScript.target?.id !== cdpTargetId); + this.#targetIds.delete(cdpTargetId); + } + }; + exports.PreloadScript = PreloadScript; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/ScriptProcessor.js +var require_ScriptProcessor = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/ScriptProcessor.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ScriptProcessor = void 0; + var protocol_js_1 = require_protocol(); + var PreloadScript_js_1 = require_PreloadScript(); + var ScriptProcessor = class { + #eventManager; + #browsingContextStorage; + #realmStorage; + #preloadScriptStorage; + #logger; + constructor(eventManager, browsingContextStorage, realmStorage, preloadScriptStorage, logger) { + this.#browsingContextStorage = browsingContextStorage; + this.#realmStorage = realmStorage; + this.#preloadScriptStorage = preloadScriptStorage; + this.#logger = logger; + this.#eventManager = eventManager; + this.#eventManager.addSubscribeHook(protocol_js_1.ChromiumBidi.Script.EventNames.RealmCreated, this.#onRealmCreatedSubscribeHook.bind(this)); + } + #onRealmCreatedSubscribeHook(contextId) { + const context = this.#browsingContextStorage.getContext(contextId); + const contextsToReport = [ + context, + ...this.#browsingContextStorage.getContext(contextId).allChildren + ]; + const realms = /* @__PURE__ */ new Set(); + for (const reportContext of contextsToReport) { + const realmsForContext = this.#realmStorage.findRealms({ + browsingContextId: reportContext.id + }); + for (const realm of realmsForContext) { + realms.add(realm); + } + } + for (const realm of realms) { + this.#eventManager.registerEvent({ + type: "event", + method: protocol_js_1.ChromiumBidi.Script.EventNames.RealmCreated, + params: realm.realmInfo + }, context.id); + } + return Promise.resolve(); + } + async addPreloadScript(params) { + const contexts = this.#browsingContextStorage.verifyTopLevelContextsList(params.contexts); + const preloadScript = new PreloadScript_js_1.PreloadScript(params, this.#logger); + this.#preloadScriptStorage.add(preloadScript); + const cdpTargets = contexts.size === 0 ? new Set(this.#browsingContextStorage.getTopLevelContexts().map((context) => context.cdpTarget)) : new Set([...contexts.values()].map((context) => context.cdpTarget)); + await preloadScript.initInTargets(cdpTargets, false); + return { + script: preloadScript.id + }; + } + async removePreloadScript(params) { + const { script: id } = params; + const scripts = this.#preloadScriptStorage.find({ id }); + if (scripts.length === 0) { + throw new protocol_js_1.NoSuchScriptException(`No preload script with id '${id}'`); + } + await Promise.all(scripts.map((script) => script.remove())); + this.#preloadScriptStorage.remove({ id }); + return {}; + } + async callFunction(params) { + const realm = await this.#getRealm(params.target); + return await realm.callFunction(params.functionDeclaration, params.awaitPromise, params.this, params.arguments, params.resultOwnership, params.serializationOptions, params.userActivation); + } + async evaluate(params) { + const realm = await this.#getRealm(params.target); + return await realm.evaluate(params.expression, params.awaitPromise, params.resultOwnership, params.serializationOptions, params.userActivation); + } + async disown(params) { + const realm = await this.#getRealm(params.target); + await Promise.all(params.handles.map(async (handle) => await realm.disown(handle))); + return {}; + } + getRealms(params) { + if (params.context !== void 0) { + this.#browsingContextStorage.getContext(params.context); + } + const realms = this.#realmStorage.findRealms({ + browsingContextId: params.context, + type: params.type + }).map((realm) => realm.realmInfo); + return { realms }; + } + async #getRealm(target) { + if ("context" in target) { + const context = this.#browsingContextStorage.getContext(target.context); + return await context.getOrCreateSandbox(target.sandbox); + } + return this.#realmStorage.getRealm({ + realmId: target.realm + }); + } + }; + exports.ScriptProcessor = ScriptProcessor; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/session/SessionProcessor.js +var require_SessionProcessor = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/session/SessionProcessor.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SessionProcessor = void 0; + var protocol_js_1 = require_protocol(); + var SessionProcessor = class { + #eventManager; + #browserCdpClient; + #initConnection; + #created = false; + constructor(eventManager, browserCdpClient, initConnection) { + this.#eventManager = eventManager; + this.#browserCdpClient = browserCdpClient; + this.#initConnection = initConnection; + } + status() { + return { ready: false, message: "already connected" }; + } + #mergeCapabilities(capabilitiesRequest) { + const mergedCapabilities = []; + for (const first2 of capabilitiesRequest.firstMatch ?? [{}]) { + const result = { + ...capabilitiesRequest.alwaysMatch + }; + for (const key of Object.keys(first2)) { + if (result[key] !== void 0) { + throw new protocol_js_1.InvalidArgumentException(`Capability ${key} in firstMatch is already defined in alwaysMatch`); + } + result[key] = first2[key]; + } + mergedCapabilities.push(result); + } + const match = mergedCapabilities.find((c) => c.browserName === "chrome") ?? mergedCapabilities[0] ?? {}; + match.unhandledPromptBehavior = this.#getUnhandledPromptBehavior(match.unhandledPromptBehavior); + return match; + } + #getUnhandledPromptBehavior(capabilityValue) { + if (capabilityValue === void 0) { + return void 0; + } + if (typeof capabilityValue === "object") { + return capabilityValue; + } + if (typeof capabilityValue !== "string") { + throw new protocol_js_1.InvalidArgumentException(`Unexpected 'unhandledPromptBehavior' type: ${typeof capabilityValue}`); + } + switch (capabilityValue) { + case "accept": + case "accept and notify": + return { + default: "accept" + /* Session.UserPromptHandlerType.Accept */ + }; + case "dismiss": + case "dismiss and notify": + return { + default: "dismiss" + /* Session.UserPromptHandlerType.Dismiss */ + }; + case "ignore": + return { + default: "ignore" + /* Session.UserPromptHandlerType.Ignore */ + }; + default: + throw new protocol_js_1.InvalidArgumentException(`Unexpected 'unhandledPromptBehavior' value: ${capabilityValue}`); + } + } + async new(params) { + if (this.#created) { + throw new Error("Session has been already created."); + } + this.#created = true; + const matchedCapabitlites = this.#mergeCapabilities(params.capabilities); + await this.#initConnection(matchedCapabitlites); + const version = await this.#browserCdpClient.sendCommand("Browser.getVersion"); + return { + sessionId: "unknown", + capabilities: { + ...matchedCapabitlites, + acceptInsecureCerts: matchedCapabitlites.acceptInsecureCerts ?? false, + browserName: version.product, + browserVersion: version.revision, + platformName: "", + setWindowRect: false, + webSocketUrl: "", + userAgent: version.userAgent + } + }; + } + async subscribe(params, channel = null) { + await this.#eventManager.subscribe(params.events, params.contexts ?? [null], channel); + return {}; + } + async unsubscribe(params, channel = null) { + await this.#eventManager.unsubscribe(params.events, params.contexts ?? [null], channel); + return {}; + } + }; + exports.SessionProcessor = SessionProcessor; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/Base64.js +var require_Base64 = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/Base64.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.base64ToString = base64ToString; + function base64ToString(base64Str) { + if ("atob" in globalThis) { + return globalThis.atob(base64Str); + } + return Buffer.from(base64Str, "base64").toString("ascii"); + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/network/NetworkUtils.js +var require_NetworkUtils = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/network/NetworkUtils.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.computeHeadersSize = computeHeadersSize; + exports.bidiNetworkHeadersFromCdpNetworkHeaders = bidiNetworkHeadersFromCdpNetworkHeaders; + exports.bidiNetworkHeadersFromCdpNetworkHeadersEntries = bidiNetworkHeadersFromCdpNetworkHeadersEntries; + exports.cdpNetworkHeadersFromBidiNetworkHeaders = cdpNetworkHeadersFromBidiNetworkHeaders; + exports.bidiNetworkHeadersFromCdpFetchHeaders = bidiNetworkHeadersFromCdpFetchHeaders; + exports.cdpFetchHeadersFromBidiNetworkHeaders = cdpFetchHeadersFromBidiNetworkHeaders; + exports.networkHeaderFromCookieHeaders = networkHeaderFromCookieHeaders; + exports.cdpAuthChallengeResponseFromBidiAuthContinueWithAuthAction = cdpAuthChallengeResponseFromBidiAuthContinueWithAuthAction; + exports.cdpToBiDiCookie = cdpToBiDiCookie; + exports.deserializeByteValue = deserializeByteValue; + exports.bidiToCdpCookie = bidiToCdpCookie; + exports.sameSiteBiDiToCdp = sameSiteBiDiToCdp; + exports.isSpecialScheme = isSpecialScheme; + exports.matchUrlPattern = matchUrlPattern; + exports.bidiBodySizeFromCdpPostDataEntries = bidiBodySizeFromCdpPostDataEntries; + exports.getTiming = getTiming; + var ErrorResponse_js_1 = require_ErrorResponse(); + var Base64_js_1 = require_Base64(); + var UrlPattern_js_1 = require_UrlPattern(); + function computeHeadersSize(headers) { + const requestHeaders = headers.reduce((acc, header) => { + return `${acc}${header.name}: ${header.value.value}\r +`; + }, ""); + return new TextEncoder().encode(requestHeaders).length; + } + function bidiNetworkHeadersFromCdpNetworkHeaders(headers) { + if (!headers) { + return []; + } + return Object.entries(headers).map(([name, value]) => ({ + name, + value: { + type: "string", + value + } + })); + } + function bidiNetworkHeadersFromCdpNetworkHeadersEntries(headers) { + if (!headers) { + return []; + } + return headers.map(({ name, value }) => ({ + name, + value: { + type: "string", + value + } + })); + } + function cdpNetworkHeadersFromBidiNetworkHeaders(headers) { + if (headers === void 0) { + return void 0; + } + return headers.reduce((result, header) => { + result[header.name] = header.value.value; + return result; + }, {}); + } + function bidiNetworkHeadersFromCdpFetchHeaders(headers) { + if (!headers) { + return []; + } + return headers.map(({ name, value }) => ({ + name, + value: { + type: "string", + value + } + })); + } + function cdpFetchHeadersFromBidiNetworkHeaders(headers) { + if (headers === void 0) { + return void 0; + } + return headers.map(({ name, value }) => ({ + name, + value: value.value + })); + } + function networkHeaderFromCookieHeaders(headers) { + if (headers === void 0) { + return void 0; + } + const value = headers.reduce((acc, value2, index) => { + if (index > 0) { + acc += ";"; + } + const cookieValue = value2.value.type === "base64" ? btoa(value2.value.value) : value2.value.value; + acc += `${value2.name}=${cookieValue}`; + return acc; + }, ""); + return { + name: "Cookie", + value: { + type: "string", + value + } + }; + } + function cdpAuthChallengeResponseFromBidiAuthContinueWithAuthAction(action) { + switch (action) { + case "default": + return "Default"; + case "cancel": + return "CancelAuth"; + case "provideCredentials": + return "ProvideCredentials"; + } + } + function cdpToBiDiCookie(cookie) { + const result = { + name: cookie.name, + value: { type: "string", value: cookie.value }, + domain: cookie.domain, + path: cookie.path, + size: cookie.size, + httpOnly: cookie.httpOnly, + secure: cookie.secure, + sameSite: cookie.sameSite === void 0 ? "none" : sameSiteCdpToBiDi(cookie.sameSite), + ...cookie.expires >= 0 ? { expiry: cookie.expires } : void 0 + }; + result[`goog:session`] = cookie.session; + result[`goog:priority`] = cookie.priority; + result[`goog:sameParty`] = cookie.sameParty; + result[`goog:sourceScheme`] = cookie.sourceScheme; + result[`goog:sourcePort`] = cookie.sourcePort; + if (cookie.partitionKey !== void 0) { + result[`goog:partitionKey`] = cookie.partitionKey; + } + if (cookie.partitionKeyOpaque !== void 0) { + result[`goog:partitionKeyOpaque`] = cookie.partitionKeyOpaque; + } + return result; + } + function deserializeByteValue(value) { + if (value.type === "base64") { + return (0, Base64_js_1.base64ToString)(value.value); + } + return value.value; + } + function bidiToCdpCookie(params, partitionKey) { + const deserializedValue = deserializeByteValue(params.cookie.value); + const result = { + name: params.cookie.name, + value: deserializedValue, + domain: params.cookie.domain, + path: params.cookie.path ?? "/", + secure: params.cookie.secure ?? false, + httpOnly: params.cookie.httpOnly ?? false, + ...partitionKey.sourceOrigin !== void 0 && { + partitionKey: { + hasCrossSiteAncestor: false, + // CDP's `partitionKey.topLevelSite` is the BiDi's `partition.sourceOrigin`. + topLevelSite: partitionKey.sourceOrigin + } + }, + ...params.cookie.expiry !== void 0 && { + expires: params.cookie.expiry + }, + ...params.cookie.sameSite !== void 0 && { + sameSite: sameSiteBiDiToCdp(params.cookie.sameSite) + } + }; + if (params.cookie[`goog:url`] !== void 0) { + result.url = params.cookie[`goog:url`]; + } + if (params.cookie[`goog:priority`] !== void 0) { + result.priority = params.cookie[`goog:priority`]; + } + if (params.cookie[`goog:sameParty`] !== void 0) { + result.sameParty = params.cookie[`goog:sameParty`]; + } + if (params.cookie[`goog:sourceScheme`] !== void 0) { + result.sourceScheme = params.cookie[`goog:sourceScheme`]; + } + if (params.cookie[`goog:sourcePort`] !== void 0) { + result.sourcePort = params.cookie[`goog:sourcePort`]; + } + return result; + } + function sameSiteCdpToBiDi(sameSite) { + switch (sameSite) { + case "Strict": + return "strict"; + case "None": + return "none"; + case "Lax": + return "lax"; + default: + return "lax"; + } + } + function sameSiteBiDiToCdp(sameSite) { + switch (sameSite) { + case "strict": + return "Strict"; + case "lax": + return "Lax"; + case "none": + return "None"; + } + throw new ErrorResponse_js_1.InvalidArgumentException(`Unknown 'sameSite' value ${sameSite}`); + } + function isSpecialScheme(protocol) { + return ["ftp", "file", "http", "https", "ws", "wss"].includes(protocol.replace(/:$/, "")); + } + function matchUrlPattern(urlPattern, url) { + switch (urlPattern.type) { + case "string": { + const pattern = new UrlPattern_js_1.URLPattern(urlPattern.pattern); + return new UrlPattern_js_1.URLPattern({ + protocol: pattern.protocol, + hostname: pattern.hostname, + port: pattern.port, + pathname: pattern.pathname, + search: pattern.search + }).test(url); + } + case "pattern": + return new UrlPattern_js_1.URLPattern(urlPattern).test(url); + } + } + function bidiBodySizeFromCdpPostDataEntries(entries) { + let size = 0; + for (const entry of entries) { + size += atob(entry.bytes ?? "").length; + } + return size; + } + function getTiming(timing) { + if (!timing) { + return 0; + } + if (timing < 0) { + return 0; + } + return timing; + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/storage/StorageProcessor.js +var require_StorageProcessor = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/storage/StorageProcessor.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.StorageProcessor = void 0; + var protocol_js_1 = require_protocol(); + var assert_js_1 = require_assert(); + var log_js_1 = require_log(); + var NetworkProcessor_js_1 = require_NetworkProcessor(); + var NetworkUtils_js_1 = require_NetworkUtils(); + var StorageProcessor = class { + #browserCdpClient; + #browsingContextStorage; + #logger; + constructor(browserCdpClient, browsingContextStorage, logger) { + this.#browsingContextStorage = browsingContextStorage; + this.#browserCdpClient = browserCdpClient; + this.#logger = logger; + } + async deleteCookies(params) { + const partitionKey = this.#expandStoragePartitionSpec(params.partition); + let cdpResponse; + try { + cdpResponse = await this.#browserCdpClient.sendCommand("Storage.getCookies", { + browserContextId: this.#getCdpBrowserContextId(partitionKey) + }); + } catch (err) { + if (this.#isNoSuchUserContextError(err)) { + throw new protocol_js_1.NoSuchUserContextException(err.message); + } + throw err; + } + const cdpCookiesToDelete = cdpResponse.cookies.filter( + // CDP's partition key is the source origin. If the request specifies the + // `sourceOrigin` partition key, only cookies with the requested source origin + // are returned. + (c) => partitionKey.sourceOrigin === void 0 || c.partitionKey?.topLevelSite === partitionKey.sourceOrigin + ).filter((cdpCookie) => { + const bidiCookie = (0, NetworkUtils_js_1.cdpToBiDiCookie)(cdpCookie); + return this.#matchCookie(bidiCookie, params.filter); + }).map((cookie) => ({ + ...cookie, + // Set expiry to pass date to delete the cookie. + expires: 1 + })); + await this.#browserCdpClient.sendCommand("Storage.setCookies", { + cookies: cdpCookiesToDelete, + browserContextId: this.#getCdpBrowserContextId(partitionKey) + }); + return { + partitionKey + }; + } + async getCookies(params) { + const partitionKey = this.#expandStoragePartitionSpec(params.partition); + let cdpResponse; + try { + cdpResponse = await this.#browserCdpClient.sendCommand("Storage.getCookies", { + browserContextId: this.#getCdpBrowserContextId(partitionKey) + }); + } catch (err) { + if (this.#isNoSuchUserContextError(err)) { + throw new protocol_js_1.NoSuchUserContextException(err.message); + } + throw err; + } + const filteredBiDiCookies = cdpResponse.cookies.filter( + // CDP's partition key is the source origin. If the request specifies the + // `sourceOrigin` partition key, only cookies with the requested source origin + // are returned. + (c) => partitionKey.sourceOrigin === void 0 || c.partitionKey?.topLevelSite === partitionKey.sourceOrigin + ).map((c) => (0, NetworkUtils_js_1.cdpToBiDiCookie)(c)).filter((c) => this.#matchCookie(c, params.filter)); + return { + cookies: filteredBiDiCookies, + partitionKey + }; + } + async setCookie(params) { + const partitionKey = this.#expandStoragePartitionSpec(params.partition); + const cdpCookie = (0, NetworkUtils_js_1.bidiToCdpCookie)(params, partitionKey); + try { + await this.#browserCdpClient.sendCommand("Storage.setCookies", { + cookies: [cdpCookie], + browserContextId: this.#getCdpBrowserContextId(partitionKey) + }); + } catch (err) { + if (this.#isNoSuchUserContextError(err)) { + throw new protocol_js_1.NoSuchUserContextException(err.message); + } + this.#logger?.(log_js_1.LogType.debugError, err); + throw new protocol_js_1.UnableToSetCookieException(err.toString()); + } + return { + partitionKey + }; + } + #isNoSuchUserContextError(err) { + return err.message?.startsWith("Failed to find browser context for id"); + } + #getCdpBrowserContextId(partitionKey) { + return partitionKey.userContext === "default" ? void 0 : partitionKey.userContext; + } + #expandStoragePartitionSpecByBrowsingContext(descriptor) { + const browsingContextId = descriptor.context; + const browsingContext = this.#browsingContextStorage.getContext(browsingContextId); + return { + userContext: browsingContext.userContext + }; + } + #expandStoragePartitionSpecByStorageKey(descriptor) { + const unsupportedPartitionKeys = /* @__PURE__ */ new Map(); + let sourceOrigin = descriptor.sourceOrigin; + if (sourceOrigin !== void 0) { + const url = NetworkProcessor_js_1.NetworkProcessor.parseUrlString(sourceOrigin); + if (url.origin === "null") { + sourceOrigin = url.origin; + } else { + sourceOrigin = `${url.protocol}//${url.hostname}`; + } + } + for (const [key, value] of Object.entries(descriptor)) { + if (key !== void 0 && value !== void 0 && !["type", "sourceOrigin", "userContext"].includes(key)) { + unsupportedPartitionKeys.set(key, value); + } + } + if (unsupportedPartitionKeys.size > 0) { + this.#logger?.(log_js_1.LogType.debugInfo, `Unsupported partition keys: ${JSON.stringify(Object.fromEntries(unsupportedPartitionKeys))}`); + } + const userContext = descriptor.userContext ?? "default"; + return { + userContext, + ...sourceOrigin === void 0 ? {} : { sourceOrigin } + }; + } + #expandStoragePartitionSpec(partitionSpec) { + if (partitionSpec === void 0) { + return { userContext: "default" }; + } + if (partitionSpec.type === "context") { + return this.#expandStoragePartitionSpecByBrowsingContext(partitionSpec); + } + (0, assert_js_1.assert)(partitionSpec.type === "storageKey", "Unknown partition type"); + return this.#expandStoragePartitionSpecByStorageKey(partitionSpec); + } + #matchCookie(cookie, filter2) { + if (filter2 === void 0) { + return true; + } + return (filter2.domain === void 0 || filter2.domain === cookie.domain) && (filter2.name === void 0 || filter2.name === cookie.name) && // `value` contains fields `type` and `value`. + (filter2.value === void 0 || (0, NetworkUtils_js_1.deserializeByteValue)(filter2.value) === (0, NetworkUtils_js_1.deserializeByteValue)(cookie.value)) && (filter2.path === void 0 || filter2.path === cookie.path) && (filter2.size === void 0 || filter2.size === cookie.size) && (filter2.httpOnly === void 0 || filter2.httpOnly === cookie.httpOnly) && (filter2.secure === void 0 || filter2.secure === cookie.secure) && (filter2.sameSite === void 0 || filter2.sameSite === cookie.sameSite) && (filter2.expiry === void 0 || filter2.expiry === cookie.expiry); + } + }; + exports.StorageProcessor = StorageProcessor; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/OutgoingMessage.js +var require_OutgoingMessage = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/OutgoingMessage.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.OutgoingMessage = void 0; + var OutgoingMessage = class { + #message; + #channel; + constructor(message, channel = null) { + this.#message = message; + this.#channel = channel; + } + static createFromPromise(messagePromise, channel) { + return messagePromise.then((message) => { + if (message.kind === "success") { + return { + kind: "success", + value: new OutgoingMessage(message.value, channel) + }; + } + return message; + }); + } + static createResolved(message, channel) { + return Promise.resolve({ + kind: "success", + value: new OutgoingMessage(message, channel) + }); + } + get message() { + return this.#message; + } + get channel() { + return this.#channel; + } + }; + exports.OutgoingMessage = OutgoingMessage; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/CommandProcessor.js +var require_CommandProcessor = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/CommandProcessor.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.CommandProcessor = void 0; + var protocol_js_1 = require_protocol(); + var EventEmitter_js_1 = require_EventEmitter(); + var log_js_1 = require_log(); + var BidiNoOpParser_js_1 = require_BidiNoOpParser(); + var BrowserProcessor_js_1 = require_BrowserProcessor(); + var CdpProcessor_js_1 = require_CdpProcessor(); + var BrowsingContextProcessor_js_1 = require_BrowsingContextProcessor(); + var InputProcessor_js_1 = require_InputProcessor(); + var NetworkProcessor_js_1 = require_NetworkProcessor(); + var PermissionsProcessor_js_1 = require_PermissionsProcessor(); + var ScriptProcessor_js_1 = require_ScriptProcessor(); + var SessionProcessor_js_1 = require_SessionProcessor(); + var StorageProcessor_js_1 = require_StorageProcessor(); + var OutgoingMessage_js_1 = require_OutgoingMessage(); + var CommandProcessor = class extends EventEmitter_js_1.EventEmitter { + // keep-sorted start + #bluetoothProcessor; + #browserProcessor; + #browsingContextProcessor; + #cdpProcessor; + #inputProcessor; + #networkProcessor; + #permissionsProcessor; + #scriptProcessor; + #sessionProcessor; + #storageProcessor; + // keep-sorted end + #parser; + #logger; + constructor(cdpConnection, browserCdpClient, eventManager, browsingContextStorage, realmStorage, preloadScriptStorage, networkStorage, bluetoothProcessor, parser = new BidiNoOpParser_js_1.BidiNoOpParser(), initConnection, logger) { + super(); + this.#parser = parser; + this.#logger = logger; + this.#bluetoothProcessor = bluetoothProcessor; + this.#browserProcessor = new BrowserProcessor_js_1.BrowserProcessor(browserCdpClient); + this.#browsingContextProcessor = new BrowsingContextProcessor_js_1.BrowsingContextProcessor(browserCdpClient, browsingContextStorage, eventManager); + this.#cdpProcessor = new CdpProcessor_js_1.CdpProcessor(browsingContextStorage, realmStorage, cdpConnection, browserCdpClient); + this.#inputProcessor = new InputProcessor_js_1.InputProcessor(browsingContextStorage); + this.#networkProcessor = new NetworkProcessor_js_1.NetworkProcessor(browsingContextStorage, networkStorage); + this.#permissionsProcessor = new PermissionsProcessor_js_1.PermissionsProcessor(browserCdpClient); + this.#scriptProcessor = new ScriptProcessor_js_1.ScriptProcessor(eventManager, browsingContextStorage, realmStorage, preloadScriptStorage, logger); + this.#sessionProcessor = new SessionProcessor_js_1.SessionProcessor(eventManager, browserCdpClient, initConnection); + this.#storageProcessor = new StorageProcessor_js_1.StorageProcessor(browserCdpClient, browsingContextStorage, logger); + } + async #processCommand(command) { + switch (command.method) { + case "session.end": + break; + case "bluetooth.handleRequestDevicePrompt": + return await this.#bluetoothProcessor.handleRequestDevicePrompt(this.#parser.parseHandleRequestDevicePromptParams(command.params)); + case "browser.close": + return this.#browserProcessor.close(); + case "browser.createUserContext": + return await this.#browserProcessor.createUserContext(command.params); + case "browser.getClientWindows": + throw new protocol_js_1.UnknownErrorException(`Method ${command.method} is not implemented.`); + case "browser.getUserContexts": + return await this.#browserProcessor.getUserContexts(); + case "browser.removeUserContext": + return await this.#browserProcessor.removeUserContext(this.#parser.parseRemoveUserContextParams(command.params)); + case "browser.setClientWindowState": + throw new protocol_js_1.UnknownErrorException(`Method ${command.method} is not implemented.`); + case "browsingContext.activate": + return await this.#browsingContextProcessor.activate(this.#parser.parseActivateParams(command.params)); + case "browsingContext.captureScreenshot": + return await this.#browsingContextProcessor.captureScreenshot(this.#parser.parseCaptureScreenshotParams(command.params)); + case "browsingContext.close": + return await this.#browsingContextProcessor.close(this.#parser.parseCloseParams(command.params)); + case "browsingContext.create": + return await this.#browsingContextProcessor.create(this.#parser.parseCreateParams(command.params)); + case "browsingContext.getTree": + return this.#browsingContextProcessor.getTree(this.#parser.parseGetTreeParams(command.params)); + case "browsingContext.handleUserPrompt": + return await this.#browsingContextProcessor.handleUserPrompt(this.#parser.parseHandleUserPromptParams(command.params)); + case "browsingContext.locateNodes": + return await this.#browsingContextProcessor.locateNodes(this.#parser.parseLocateNodesParams(command.params)); + case "browsingContext.navigate": + return await this.#browsingContextProcessor.navigate(this.#parser.parseNavigateParams(command.params)); + case "browsingContext.print": + return await this.#browsingContextProcessor.print(this.#parser.parsePrintParams(command.params)); + case "browsingContext.reload": + return await this.#browsingContextProcessor.reload(this.#parser.parseReloadParams(command.params)); + case "browsingContext.setViewport": + return await this.#browsingContextProcessor.setViewport(this.#parser.parseSetViewportParams(command.params)); + case "browsingContext.traverseHistory": + return await this.#browsingContextProcessor.traverseHistory(this.#parser.parseTraverseHistoryParams(command.params)); + case "cdp.getSession": + return this.#cdpProcessor.getSession(this.#parser.parseGetSessionParams(command.params)); + case "cdp.resolveRealm": + return this.#cdpProcessor.resolveRealm(this.#parser.parseResolveRealmParams(command.params)); + case "cdp.sendCommand": + return await this.#cdpProcessor.sendCommand(this.#parser.parseSendCommandParams(command.params)); + case "input.performActions": + return await this.#inputProcessor.performActions(this.#parser.parsePerformActionsParams(command.params)); + case "input.releaseActions": + return await this.#inputProcessor.releaseActions(this.#parser.parseReleaseActionsParams(command.params)); + case "input.setFiles": + return await this.#inputProcessor.setFiles(this.#parser.parseSetFilesParams(command.params)); + case "network.addIntercept": + return await this.#networkProcessor.addIntercept(this.#parser.parseAddInterceptParams(command.params)); + case "network.continueRequest": + return await this.#networkProcessor.continueRequest(this.#parser.parseContinueRequestParams(command.params)); + case "network.continueResponse": + return await this.#networkProcessor.continueResponse(this.#parser.parseContinueResponseParams(command.params)); + case "network.continueWithAuth": + return await this.#networkProcessor.continueWithAuth(this.#parser.parseContinueWithAuthParams(command.params)); + case "network.failRequest": + return await this.#networkProcessor.failRequest(this.#parser.parseFailRequestParams(command.params)); + case "network.provideResponse": + return await this.#networkProcessor.provideResponse(this.#parser.parseProvideResponseParams(command.params)); + case "network.removeIntercept": + return await this.#networkProcessor.removeIntercept(this.#parser.parseRemoveInterceptParams(command.params)); + case "network.setCacheBehavior": + return await this.#networkProcessor.setCacheBehavior(this.#parser.parseSetCacheBehavior(command.params)); + case "permissions.setPermission": + return await this.#permissionsProcessor.setPermissions(this.#parser.parseSetPermissionsParams(command.params)); + case "script.addPreloadScript": + return await this.#scriptProcessor.addPreloadScript(this.#parser.parseAddPreloadScriptParams(command.params)); + case "script.callFunction": + return await this.#scriptProcessor.callFunction(this.#parser.parseCallFunctionParams(this.#processTargetParams(command.params))); + case "script.disown": + return await this.#scriptProcessor.disown(this.#parser.parseDisownParams(this.#processTargetParams(command.params))); + case "script.evaluate": + return await this.#scriptProcessor.evaluate(this.#parser.parseEvaluateParams(this.#processTargetParams(command.params))); + case "script.getRealms": + return this.#scriptProcessor.getRealms(this.#parser.parseGetRealmsParams(command.params)); + case "script.removePreloadScript": + return await this.#scriptProcessor.removePreloadScript(this.#parser.parseRemovePreloadScriptParams(command.params)); + case "session.new": + return await this.#sessionProcessor.new(command.params); + case "session.status": + return this.#sessionProcessor.status(); + case "session.subscribe": + return await this.#sessionProcessor.subscribe(this.#parser.parseSubscribeParams(command.params), command.channel); + case "session.unsubscribe": + return await this.#sessionProcessor.unsubscribe(this.#parser.parseSubscribeParams(command.params), command.channel); + case "storage.deleteCookies": + return await this.#storageProcessor.deleteCookies(this.#parser.parseDeleteCookiesParams(command.params)); + case "storage.getCookies": + return await this.#storageProcessor.getCookies(this.#parser.parseGetCookiesParams(command.params)); + case "storage.setCookie": + return await this.#storageProcessor.setCookie(this.#parser.parseSetCookieParams(command.params)); + } + throw new protocol_js_1.UnknownCommandException(`Unknown command '${command.method}'.`); + } + // Workaround for as zod.union always take the first schema + // https://github.com/w3c/webdriver-bidi/issues/635 + #processTargetParams(params) { + if (typeof params === "object" && params && "target" in params && typeof params.target === "object" && params.target && "context" in params.target) { + delete params.target["realm"]; + } + return params; + } + async processCommand(command) { + try { + const result = await this.#processCommand(command); + const response = { + type: "success", + id: command.id, + result + }; + this.emit("response", { + message: OutgoingMessage_js_1.OutgoingMessage.createResolved(response, command.channel), + event: command.method + }); + } catch (e) { + if (e instanceof protocol_js_1.Exception) { + this.emit("response", { + message: OutgoingMessage_js_1.OutgoingMessage.createResolved(e.toErrorResponse(command.id), command.channel), + event: command.method + }); + } else { + const error = e; + this.#logger?.(log_js_1.LogType.bidi, error); + this.emit("response", { + message: OutgoingMessage_js_1.OutgoingMessage.createResolved(new protocol_js_1.UnknownErrorException(error.message, error.stack).toErrorResponse(command.id), command.channel), + event: command.method + }); + } + } + } + }; + exports.CommandProcessor = CommandProcessor; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/bluetooth/BluetoothProcessor.js +var require_BluetoothProcessor = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/bluetooth/BluetoothProcessor.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BluetoothProcessor = void 0; + var BluetoothProcessor = class { + #eventManager; + #browsingContextStorage; + constructor(eventManager, browsingContextStorage) { + this.#eventManager = eventManager; + this.#browsingContextStorage = browsingContextStorage; + } + onCdpTargetCreated(cdpTarget) { + cdpTarget.cdpClient.on("DeviceAccess.deviceRequestPrompted", (event) => { + this.#eventManager.registerEvent({ + type: "event", + method: "bluetooth.requestDevicePromptUpdated", + params: { + context: cdpTarget.id, + prompt: event.id, + devices: event.devices + } + }, cdpTarget.id); + }); + } + async handleRequestDevicePrompt(params) { + const context = this.#browsingContextStorage.getContext(params.context); + if (params.accept) { + await context.cdpTarget.cdpClient.sendCommand("DeviceAccess.selectPrompt", { + id: params.prompt, + deviceId: params.device + }); + } else { + await context.cdpTarget.cdpClient.sendCommand("DeviceAccess.cancelPrompt", { + id: params.prompt + }); + } + return {}; + } + }; + exports.BluetoothProcessor = BluetoothProcessor; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/Deferred.js +var require_Deferred = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/Deferred.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Deferred = void 0; + var Deferred2 = class { + #isFinished = false; + #promise; + #result; + #resolve; + #reject; + get isFinished() { + return this.#isFinished; + } + get result() { + if (!this.#isFinished) { + throw new Error("Deferred is not finished yet"); + } + return this.#result; + } + constructor() { + this.#promise = new Promise((resolve, reject) => { + this.#resolve = resolve; + this.#reject = reject; + }); + this.#promise.catch((_error) => { + }); + } + then(onFulfilled, onRejected) { + return this.#promise.then(onFulfilled, onRejected); + } + catch(onRejected) { + return this.#promise.catch(onRejected); + } + resolve(value) { + this.#result = value; + if (!this.#isFinished) { + this.#isFinished = true; + this.#resolve(value); + } + } + reject(reason) { + if (!this.#isFinished) { + this.#isFinished = true; + this.#reject(reason); + } + } + finally(onFinally) { + return this.#promise.finally(onFinally); + } + [Symbol.toStringTag] = "Promise"; + }; + exports.Deferred = Deferred2; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/unitConversions.js +var require_unitConversions = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/unitConversions.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.inchesFromCm = inchesFromCm; + function inchesFromCm(cm) { + return cm / 2.54; + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/Realm.js +var require_Realm = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/Realm.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Realm = void 0; + var protocol_js_1 = require_protocol(); + var log_js_1 = require_log(); + var uuid_js_1 = require_uuid(); + var ChannelProxy_js_1 = require_ChannelProxy(); + var _cdpClient, _eventManager, _executionContextId, _logger, _origin, _realmId, _realmStorage, _registerEvent, registerEvent_fn, _cdpRemoteObjectToCallArgument, cdpRemoteObjectToCallArgument_fn, _flattenKeyValuePairs, flattenKeyValuePairs_fn, _flattenValueList, flattenValueList_fn, _serializeCdpExceptionDetails, serializeCdpExceptionDetails_fn, _getExceptionResult, getExceptionResult_fn, _getSerializationOptions, getSerializationOptions_fn, _getAdditionalSerializationParameters, getAdditionalSerializationParameters_fn, _getMaxObjectDepth, getMaxObjectDepth_fn, _releaseObject, releaseObject_fn; + var _Realm = class { + constructor(cdpClient, eventManager, executionContextId, logger, origin, realmId, realmStorage) { + __privateAdd(this, _registerEvent); + __privateAdd(this, _flattenKeyValuePairs); + __privateAdd(this, _flattenValueList); + __privateAdd(this, _serializeCdpExceptionDetails); + __privateAdd(this, _getExceptionResult); + __privateAdd(this, _releaseObject); + __privateAdd(this, _cdpClient, void 0); + __privateAdd(this, _eventManager, void 0); + __privateAdd(this, _executionContextId, void 0); + __privateAdd(this, _logger, void 0); + __privateAdd(this, _origin, void 0); + __privateAdd(this, _realmId, void 0); + __privateAdd(this, _realmStorage, void 0); + __privateSet(this, _cdpClient, cdpClient); + __privateSet(this, _eventManager, eventManager); + __privateSet(this, _executionContextId, executionContextId); + __privateSet(this, _logger, logger); + __privateSet(this, _origin, origin); + __privateSet(this, _realmId, realmId); + __privateSet(this, _realmStorage, realmStorage); + __privateGet(this, _realmStorage).addRealm(this); + } + cdpToBidiValue(cdpValue, resultOwnership) { + const bidiValue = this.serializeForBiDi(cdpValue.result.deepSerializedValue, /* @__PURE__ */ new Map()); + if (cdpValue.result.objectId) { + const objectId = cdpValue.result.objectId; + if (resultOwnership === "root") { + bidiValue.handle = objectId; + __privateGet(this, _realmStorage).knownHandlesToRealmMap.set(objectId, this.realmId); + } else { + void __privateMethod(this, _releaseObject, releaseObject_fn).call(this, objectId).catch((error) => { + var _a3; + return (_a3 = __privateGet(this, _logger)) == null ? void 0 : _a3.call(this, log_js_1.LogType.debugError, error); + }); + } + } + return bidiValue; + } + /** + * Relies on the CDP to implement proper BiDi serialization, except: + * * CDP integer property `backendNodeId` is replaced with `sharedId` of + * `{documentId}_element_{backendNodeId}`; + * * CDP integer property `weakLocalObjectReference` is replaced with UUID `internalId` + * using unique-per serialization `internalIdMap`. + * * CDP type `platformobject` is replaced with `object`. + * @param deepSerializedValue - CDP value to be converted to BiDi. + * @param internalIdMap - Map from CDP integer `weakLocalObjectReference` to BiDi UUID + * `internalId`. + */ + serializeForBiDi(deepSerializedValue, internalIdMap) { + if (Object.hasOwn(deepSerializedValue, "weakLocalObjectReference")) { + const weakLocalObjectReference = deepSerializedValue.weakLocalObjectReference; + if (!internalIdMap.has(weakLocalObjectReference)) { + internalIdMap.set(weakLocalObjectReference, (0, uuid_js_1.uuidv4)()); + } + deepSerializedValue.internalId = internalIdMap.get(weakLocalObjectReference); + delete deepSerializedValue["weakLocalObjectReference"]; + } + if (deepSerializedValue.type === "node" && Object.hasOwn(deepSerializedValue?.value, "frameId")) { + delete deepSerializedValue.value["frameId"]; + } + if (deepSerializedValue.type === "platformobject") { + return { type: "object" }; + } + const bidiValue = deepSerializedValue.value; + if (bidiValue === void 0) { + return deepSerializedValue; + } + if (["array", "set", "htmlcollection", "nodelist"].includes(deepSerializedValue.type)) { + for (const i in bidiValue) { + bidiValue[i] = this.serializeForBiDi(bidiValue[i], internalIdMap); + } + } + if (["object", "map"].includes(deepSerializedValue.type)) { + for (const i in bidiValue) { + bidiValue[i] = [ + this.serializeForBiDi(bidiValue[i][0], internalIdMap), + this.serializeForBiDi(bidiValue[i][1], internalIdMap) + ]; + } + } + return deepSerializedValue; + } + get realmId() { + return __privateGet(this, _realmId); + } + get executionContextId() { + return __privateGet(this, _executionContextId); + } + get origin() { + return __privateGet(this, _origin); + } + get source() { + return { + realm: this.realmId + }; + } + get cdpClient() { + return __privateGet(this, _cdpClient); + } + get baseInfo() { + return { + realm: this.realmId, + origin: this.origin + }; + } + async evaluate(expression, awaitPromise, resultOwnership = "none", serializationOptions = {}, userActivation = false, includeCommandLineApi = false) { + var _a3; + const cdpEvaluateResult = await this.cdpClient.sendCommand("Runtime.evaluate", { + contextId: this.executionContextId, + expression, + awaitPromise, + serializationOptions: __privateMethod(_a3 = _Realm, _getSerializationOptions, getSerializationOptions_fn).call(_a3, "deep", serializationOptions), + userGesture: userActivation, + includeCommandLineAPI: includeCommandLineApi + }); + if (cdpEvaluateResult.exceptionDetails) { + return await __privateMethod(this, _getExceptionResult, getExceptionResult_fn).call(this, cdpEvaluateResult.exceptionDetails, 0, resultOwnership); + } + return { + realm: this.realmId, + result: this.cdpToBidiValue(cdpEvaluateResult, resultOwnership), + type: "success" + }; + } + initialize() { + __privateMethod(this, _registerEvent, registerEvent_fn).call(this, { + type: "event", + method: protocol_js_1.ChromiumBidi.Script.EventNames.RealmCreated, + params: this.realmInfo + }); + } + /** + * Serializes a given CDP object into BiDi, keeping references in the + * target's `globalThis`. + */ + async serializeCdpObject(cdpRemoteObject, resultOwnership) { + var _a3; + const argument = __privateMethod(_a3 = _Realm, _cdpRemoteObjectToCallArgument, cdpRemoteObjectToCallArgument_fn).call(_a3, cdpRemoteObject); + const cdpValue = await this.cdpClient.sendCommand("Runtime.callFunctionOn", { + functionDeclaration: String((remoteObject) => remoteObject), + awaitPromise: false, + arguments: [argument], + serializationOptions: { + serialization: "deep" + }, + executionContextId: this.executionContextId + }); + return this.cdpToBidiValue(cdpValue, resultOwnership); + } + /** + * Gets the string representation of an object. This is equivalent to + * calling `toString()` on the object value. + */ + async stringifyObject(cdpRemoteObject) { + const { result } = await this.cdpClient.sendCommand("Runtime.callFunctionOn", { + functionDeclaration: String((remoteObject) => String(remoteObject)), + awaitPromise: false, + arguments: [cdpRemoteObject], + returnByValue: true, + executionContextId: this.executionContextId + }); + return result.value; + } + async callFunction(functionDeclaration, awaitPromise, thisLocalValue = { + type: "undefined" + }, argumentsLocalValues = [], resultOwnership = "none", serializationOptions = {}, userActivation = false) { + var _a3; + const callFunctionAndSerializeScript = `(...args) => { + function callFunction(f, args) { + const deserializedThis = args.shift(); + const deserializedArgs = args; + return f.apply(deserializedThis, deserializedArgs); + } + return callFunction(( + ${functionDeclaration} + ), args); + }`; + const thisAndArgumentsList = [ + await this.deserializeForCdp(thisLocalValue), + ...await Promise.all(argumentsLocalValues.map(async (argumentLocalValue) => await this.deserializeForCdp(argumentLocalValue))) + ]; + let cdpCallFunctionResult; + try { + cdpCallFunctionResult = await this.cdpClient.sendCommand("Runtime.callFunctionOn", { + functionDeclaration: callFunctionAndSerializeScript, + awaitPromise, + arguments: thisAndArgumentsList, + serializationOptions: __privateMethod(_a3 = _Realm, _getSerializationOptions, getSerializationOptions_fn).call(_a3, "deep", serializationOptions), + executionContextId: this.executionContextId, + userGesture: userActivation + }); + } catch (error) { + if (error.code === -32e3 && [ + "Could not find object with given id", + "Argument should belong to the same JavaScript world as target object", + "Invalid remote object id" + ].includes(error.message)) { + throw new protocol_js_1.NoSuchHandleException("Handle was not found."); + } + throw error; + } + if (cdpCallFunctionResult.exceptionDetails) { + return await __privateMethod(this, _getExceptionResult, getExceptionResult_fn).call(this, cdpCallFunctionResult.exceptionDetails, 1, resultOwnership); + } + return { + type: "success", + result: this.cdpToBidiValue(cdpCallFunctionResult, resultOwnership), + realm: this.realmId + }; + } + async deserializeForCdp(localValue) { + if ("handle" in localValue && localValue.handle) { + return { objectId: localValue.handle }; + } else if ("handle" in localValue || "sharedId" in localValue) { + throw new protocol_js_1.NoSuchHandleException("Handle was not found."); + } + switch (localValue.type) { + case "undefined": + return { unserializableValue: "undefined" }; + case "null": + return { unserializableValue: "null" }; + case "string": + return { value: localValue.value }; + case "number": + if (localValue.value === "NaN") { + return { unserializableValue: "NaN" }; + } else if (localValue.value === "-0") { + return { unserializableValue: "-0" }; + } else if (localValue.value === "Infinity") { + return { unserializableValue: "Infinity" }; + } else if (localValue.value === "-Infinity") { + return { unserializableValue: "-Infinity" }; + } + return { + value: localValue.value + }; + case "boolean": + return { value: Boolean(localValue.value) }; + case "bigint": + return { + unserializableValue: `BigInt(${JSON.stringify(localValue.value)})` + }; + case "date": + return { + unserializableValue: `new Date(Date.parse(${JSON.stringify(localValue.value)}))` + }; + case "regexp": + return { + unserializableValue: `new RegExp(${JSON.stringify(localValue.value.pattern)}, ${JSON.stringify(localValue.value.flags)})` + }; + case "map": { + const keyValueArray = await __privateMethod(this, _flattenKeyValuePairs, flattenKeyValuePairs_fn).call(this, localValue.value); + const { result } = await this.cdpClient.sendCommand("Runtime.callFunctionOn", { + functionDeclaration: String((...args) => { + const result2 = /* @__PURE__ */ new Map(); + for (let i = 0; i < args.length; i += 2) { + result2.set(args[i], args[i + 1]); + } + return result2; + }), + awaitPromise: false, + arguments: keyValueArray, + returnByValue: false, + executionContextId: this.executionContextId + }); + return { objectId: result.objectId }; + } + case "object": { + const keyValueArray = await __privateMethod(this, _flattenKeyValuePairs, flattenKeyValuePairs_fn).call(this, localValue.value); + const { result } = await this.cdpClient.sendCommand("Runtime.callFunctionOn", { + functionDeclaration: String((...args) => { + const result2 = {}; + for (let i = 0; i < args.length; i += 2) { + const key = args[i]; + result2[key] = args[i + 1]; + } + return result2; + }), + awaitPromise: false, + arguments: keyValueArray, + returnByValue: false, + executionContextId: this.executionContextId + }); + return { objectId: result.objectId }; + } + case "array": { + const args = await __privateMethod(this, _flattenValueList, flattenValueList_fn).call(this, localValue.value); + const { result } = await this.cdpClient.sendCommand("Runtime.callFunctionOn", { + functionDeclaration: String((...args2) => args2), + awaitPromise: false, + arguments: args, + returnByValue: false, + executionContextId: this.executionContextId + }); + return { objectId: result.objectId }; + } + case "set": { + const args = await __privateMethod(this, _flattenValueList, flattenValueList_fn).call(this, localValue.value); + const { result } = await this.cdpClient.sendCommand("Runtime.callFunctionOn", { + functionDeclaration: String((...args2) => new Set(args2)), + awaitPromise: false, + arguments: args, + returnByValue: false, + executionContextId: this.executionContextId + }); + return { objectId: result.objectId }; + } + case "channel": { + const channelProxy = new ChannelProxy_js_1.ChannelProxy(localValue.value, __privateGet(this, _logger)); + const channelProxySendMessageHandle = await channelProxy.init(this, __privateGet(this, _eventManager)); + return { objectId: channelProxySendMessageHandle }; + } + } + throw new Error(`Value ${JSON.stringify(localValue)} is not deserializable.`); + } + async disown(handle) { + if (__privateGet(this, _realmStorage).knownHandlesToRealmMap.get(handle) !== this.realmId) { + return; + } + await __privateMethod(this, _releaseObject, releaseObject_fn).call(this, handle); + __privateGet(this, _realmStorage).knownHandlesToRealmMap.delete(handle); + } + dispose() { + __privateMethod(this, _registerEvent, registerEvent_fn).call(this, { + type: "event", + method: protocol_js_1.ChromiumBidi.Script.EventNames.RealmDestroyed, + params: { + realm: this.realmId + } + }); + } + }; + var Realm3 = _Realm; + _cdpClient = new WeakMap(); + _eventManager = new WeakMap(); + _executionContextId = new WeakMap(); + _logger = new WeakMap(); + _origin = new WeakMap(); + _realmId = new WeakMap(); + _realmStorage = new WeakMap(); + _registerEvent = new WeakSet(); + registerEvent_fn = function(event) { + if (this.associatedBrowsingContexts.length === 0) { + __privateGet(this, _eventManager).registerEvent(event, null); + } else { + for (const browsingContext of this.associatedBrowsingContexts) { + __privateGet(this, _eventManager).registerEvent(event, browsingContext.id); + } + } + }; + _cdpRemoteObjectToCallArgument = new WeakSet(); + cdpRemoteObjectToCallArgument_fn = function(cdpRemoteObject) { + if (cdpRemoteObject.objectId !== void 0) { + return { objectId: cdpRemoteObject.objectId }; + } + if (cdpRemoteObject.unserializableValue !== void 0) { + return { unserializableValue: cdpRemoteObject.unserializableValue }; + } + return { value: cdpRemoteObject.value }; + }; + _flattenKeyValuePairs = new WeakSet(); + flattenKeyValuePairs_fn = async function(mappingLocalValue) { + const keyValueArray = await Promise.all(mappingLocalValue.map(async ([key, value]) => { + let keyArg; + if (typeof key === "string") { + keyArg = { value: key }; + } else { + keyArg = await this.deserializeForCdp(key); + } + const valueArg = await this.deserializeForCdp(value); + return [keyArg, valueArg]; + })); + return keyValueArray.flat(); + }; + _flattenValueList = new WeakSet(); + flattenValueList_fn = async function(listLocalValue) { + return await Promise.all(listLocalValue.map((localValue) => this.deserializeForCdp(localValue))); + }; + _serializeCdpExceptionDetails = new WeakSet(); + serializeCdpExceptionDetails_fn = async function(cdpExceptionDetails, lineOffset, resultOwnership) { + const callFrames = cdpExceptionDetails.stackTrace?.callFrames.map((frame) => ({ + url: frame.url, + functionName: frame.functionName, + lineNumber: frame.lineNumber - lineOffset, + columnNumber: frame.columnNumber + })) ?? []; + const exception = cdpExceptionDetails.exception; + return { + exception: await this.serializeCdpObject(exception, resultOwnership), + columnNumber: cdpExceptionDetails.columnNumber, + lineNumber: cdpExceptionDetails.lineNumber - lineOffset, + stackTrace: { + callFrames + }, + text: await this.stringifyObject(exception) || cdpExceptionDetails.text + }; + }; + _getExceptionResult = new WeakSet(); + getExceptionResult_fn = async function(exceptionDetails, lineOffset, resultOwnership) { + return { + exceptionDetails: await __privateMethod(this, _serializeCdpExceptionDetails, serializeCdpExceptionDetails_fn).call(this, exceptionDetails, lineOffset, resultOwnership), + realm: this.realmId, + type: "exception" + }; + }; + _getSerializationOptions = new WeakSet(); + getSerializationOptions_fn = function(serialization, serializationOptions) { + var _a3, _b; + return { + serialization, + additionalParameters: __privateMethod(_a3 = _Realm, _getAdditionalSerializationParameters, getAdditionalSerializationParameters_fn).call(_a3, serializationOptions), + ...__privateMethod(_b = _Realm, _getMaxObjectDepth, getMaxObjectDepth_fn).call(_b, serializationOptions) + }; + }; + _getAdditionalSerializationParameters = new WeakSet(); + getAdditionalSerializationParameters_fn = function(serializationOptions) { + const additionalParameters = {}; + if (serializationOptions.maxDomDepth !== void 0) { + additionalParameters["maxNodeDepth"] = serializationOptions.maxDomDepth === null ? 1e3 : serializationOptions.maxDomDepth; + } + if (serializationOptions.includeShadowTree !== void 0) { + additionalParameters["includeShadowTree"] = serializationOptions.includeShadowTree; + } + return additionalParameters; + }; + _getMaxObjectDepth = new WeakSet(); + getMaxObjectDepth_fn = function(serializationOptions) { + return serializationOptions.maxObjectDepth === void 0 || serializationOptions.maxObjectDepth === null ? {} : { maxDepth: serializationOptions.maxObjectDepth }; + }; + _releaseObject = new WeakSet(); + releaseObject_fn = async function(handle) { + try { + await this.cdpClient.sendCommand("Runtime.releaseObject", { + objectId: handle + }); + } catch (error) { + if (!(error.code === -32e3 && error.message === "Invalid remote object id")) { + throw error; + } + } + }; + __privateAdd(Realm3, _cdpRemoteObjectToCallArgument); + __privateAdd(Realm3, _getSerializationOptions); + __privateAdd(Realm3, _getAdditionalSerializationParameters); + __privateAdd(Realm3, _getMaxObjectDepth); + exports.Realm = Realm3; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/SharedId.js +var require_SharedId = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/SharedId.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getSharedId = getSharedId; + exports.parseSharedId = parseSharedId; + var SHARED_ID_DIVIDER = "_element_"; + function getSharedId(frameId, documentId, backendNodeId) { + return `f.${frameId}.d.${documentId}.e.${backendNodeId}`; + } + function parseLegacySharedId(sharedId) { + const match = sharedId.match(new RegExp(`(.*)${SHARED_ID_DIVIDER}(.*)`)); + if (!match) { + return null; + } + const documentId = match[1]; + const elementId = match[2]; + if (documentId === void 0 || elementId === void 0) { + return null; + } + const backendNodeId = parseInt(elementId ?? ""); + if (isNaN(backendNodeId)) { + return null; + } + return { + documentId, + backendNodeId + }; + } + function parseSharedId(sharedId) { + const legacyFormattedSharedId = parseLegacySharedId(sharedId); + if (legacyFormattedSharedId !== null) { + return { ...legacyFormattedSharedId, frameId: void 0 }; + } + const match = sharedId.match(/f\.(.*)\.d\.(.*)\.e\.([0-9]*)/); + if (!match) { + return null; + } + const frameId = match[1]; + const documentId = match[2]; + const elementId = match[3]; + if (frameId === void 0 || documentId === void 0 || elementId === void 0) { + return null; + } + const backendNodeId = parseInt(elementId ?? ""); + if (isNaN(backendNodeId)) { + return null; + } + return { + frameId, + documentId, + backendNodeId + }; + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/WindowRealm.js +var require_WindowRealm = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/WindowRealm.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.WindowRealm = void 0; + var protocol_js_1 = require_protocol(); + var Realm_js_1 = require_Realm(); + var SharedId_js_1 = require_SharedId(); + var WindowRealm2 = class extends Realm_js_1.Realm { + #browsingContextId; + #browsingContextStorage; + sandbox; + constructor(browsingContextId, browsingContextStorage, cdpClient, eventManager, executionContextId, logger, origin, realmId, realmStorage, sandbox) { + super(cdpClient, eventManager, executionContextId, logger, origin, realmId, realmStorage); + this.#browsingContextId = browsingContextId; + this.#browsingContextStorage = browsingContextStorage; + this.sandbox = sandbox; + this.initialize(); + } + #getBrowsingContextId(navigableId) { + const maybeBrowsingContext = this.#browsingContextStorage.getAllContexts().find((context) => context.navigableId === navigableId); + return maybeBrowsingContext?.id ?? "UNKNOWN"; + } + get browsingContext() { + return this.#browsingContextStorage.getContext(this.#browsingContextId); + } + get associatedBrowsingContexts() { + return [this.browsingContext]; + } + get realmType() { + return "window"; + } + get realmInfo() { + return { + ...this.baseInfo, + type: this.realmType, + context: this.#browsingContextId, + sandbox: this.sandbox + }; + } + get source() { + return { + realm: this.realmId, + context: this.browsingContext.id + }; + } + serializeForBiDi(deepSerializedValue, internalIdMap) { + const bidiValue = deepSerializedValue.value; + if (deepSerializedValue.type === "node" && bidiValue !== void 0) { + if (Object.hasOwn(bidiValue, "backendNodeId")) { + let navigableId = this.browsingContext.navigableId ?? "UNKNOWN"; + if (Object.hasOwn(bidiValue, "loaderId")) { + navigableId = bidiValue.loaderId; + delete bidiValue["loaderId"]; + } + deepSerializedValue.sharedId = (0, SharedId_js_1.getSharedId)(this.#getBrowsingContextId(navigableId), navigableId, bidiValue.backendNodeId); + delete bidiValue["backendNodeId"]; + } + if (Object.hasOwn(bidiValue, "children")) { + for (const i in bidiValue.children) { + bidiValue.children[i] = this.serializeForBiDi(bidiValue.children[i], internalIdMap); + } + } + if (Object.hasOwn(bidiValue, "shadowRoot") && bidiValue.shadowRoot !== null) { + bidiValue.shadowRoot = this.serializeForBiDi(bidiValue.shadowRoot, internalIdMap); + } + if (bidiValue.namespaceURI === "") { + bidiValue.namespaceURI = null; + } + } + return super.serializeForBiDi(deepSerializedValue, internalIdMap); + } + async deserializeForCdp(localValue) { + if ("sharedId" in localValue && localValue.sharedId) { + const parsedSharedId = (0, SharedId_js_1.parseSharedId)(localValue.sharedId); + if (parsedSharedId === null) { + throw new protocol_js_1.NoSuchNodeException(`SharedId "${localValue.sharedId}" was not found.`); + } + const { documentId, backendNodeId } = parsedSharedId; + if (this.browsingContext.navigableId !== documentId) { + throw new protocol_js_1.NoSuchNodeException(`SharedId "${localValue.sharedId}" belongs to different document. Current document is ${this.browsingContext.navigableId}.`); + } + try { + const { object } = await this.cdpClient.sendCommand("DOM.resolveNode", { + backendNodeId, + executionContextId: this.executionContextId + }); + return { objectId: object.objectId }; + } catch (error) { + if (error.code === -32e3 && error.message === "No node with given id found") { + throw new protocol_js_1.NoSuchNodeException(`SharedId "${localValue.sharedId}" was not found.`); + } + throw new protocol_js_1.UnknownErrorException(error.message, error.stack); + } + } + return await super.deserializeForCdp(localValue); + } + async evaluate(expression, awaitPromise, resultOwnership, serializationOptions, userActivation, includeCommandLineApi) { + await this.#browsingContextStorage.getContext(this.#browsingContextId).targetUnblockedOrThrow(); + return await super.evaluate(expression, awaitPromise, resultOwnership, serializationOptions, userActivation, includeCommandLineApi); + } + async callFunction(functionDeclaration, awaitPromise, thisLocalValue, argumentsLocalValues, resultOwnership, serializationOptions, userActivation) { + await this.#browsingContextStorage.getContext(this.#browsingContextId).targetUnblockedOrThrow(); + return await super.callFunction(functionDeclaration, awaitPromise, thisLocalValue, argumentsLocalValues, resultOwnership, serializationOptions, userActivation); + } + }; + exports.WindowRealm = WindowRealm2; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/context/BrowsingContextImpl.js +var require_BrowsingContextImpl = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/context/BrowsingContextImpl.js"(exports) { + "use strict"; + init_cjs_shim(); + var _a3; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BrowsingContextImpl = void 0; + exports.serializeOrigin = serializeOrigin; + var protocol_js_1 = require_protocol(); + var assert_js_1 = require_assert(); + var Deferred_js_1 = require_Deferred(); + var log_js_1 = require_log(); + var unitConversions_js_1 = require_unitConversions(); + var uuid_js_1 = require_uuid(); + var WindowRealm_js_1 = require_WindowRealm(); + var _id, _parentId, _children, _browsingContextStorage, _lifecycle, _navigation, _url, _eventManager, _realmStorage, _loaderId, _cdpTarget, _defaultRealmDeferred, _logger, _previousViewport, _pendingNavigationUrl, _navigationId, _pendingNavigationId, _pendingCommandNavigation, _originalOpener, _lastUserPromptType, _unhandledPromptBehavior, _deleteAllChildren, deleteAllChildren_fn, _initListeners, initListeners_fn, _getPromptType, getPromptType_fn, _getPromptHandler, getPromptHandler_fn, _documentChanged, documentChanged_fn, _resetLifecycleIfFinished, resetLifecycleIfFinished_fn, _failLifecycleIfNotFinished, failLifecycleIfNotFinished_fn, _waitNavigation, waitNavigation_fn, _parseRect, parseRect_fn, _getLocatorDelegate, getLocatorDelegate_fn, _locateNodesByLocator, locateNodesByLocator_fn; + var BrowsingContextImpl = class { + constructor(id, parentId, userContext, cdpTarget, eventManager, browsingContextStorage, realmStorage, url, originalOpener, unhandledPromptBehavior, logger) { + __privateAdd(this, _deleteAllChildren); + __privateAdd(this, _initListeners); + __privateAdd(this, _getPromptHandler); + __privateAdd(this, _documentChanged); + __privateAdd(this, _resetLifecycleIfFinished); + __privateAdd(this, _failLifecycleIfNotFinished); + __privateAdd(this, _waitNavigation); + /** + * See + * https://w3c.github.io/webdriver-bidi/#:~:text=If%20command%20parameters%20contains%20%22clip%22%3A + */ + __privateAdd(this, _parseRect); + __privateAdd(this, _getLocatorDelegate); + __privateAdd(this, _locateNodesByLocator); + /** The ID of this browsing context. */ + __privateAdd(this, _id, void 0); + __publicField(this, "userContext"); + /** + * The ID of the parent browsing context. + * If null, this is a top-level context. + */ + __privateAdd(this, _parentId, null); + /** Direct children browsing contexts. */ + __privateAdd(this, _children, /* @__PURE__ */ new Set()); + __privateAdd(this, _browsingContextStorage, void 0); + __privateAdd(this, _lifecycle, { + DOMContentLoaded: new Deferred_js_1.Deferred(), + load: new Deferred_js_1.Deferred() + }); + __privateAdd(this, _navigation, { + withinDocument: new Deferred_js_1.Deferred() + }); + __privateAdd(this, _url, void 0); + __privateAdd(this, _eventManager, void 0); + __privateAdd(this, _realmStorage, void 0); + __privateAdd(this, _loaderId, void 0); + __privateAdd(this, _cdpTarget, void 0); + // The deferred will be resolved when the default realm is created. + __privateAdd(this, _defaultRealmDeferred, new Deferred_js_1.Deferred()); + __privateAdd(this, _logger, void 0); + // Keeps track of the previously set viewport. + __privateAdd(this, _previousViewport, { width: 0, height: 0 }); + // The URL of the navigation that is currently in progress. A workaround of the CDP + // lacking URL for the pending navigation events, e.g. `Page.frameStartedLoading`. + // Set on `Page.navigate`, `Page.reload` commands, on `Page.frameRequestedNavigation` or + // on a deprecated `Page.frameScheduledNavigation` event. The latest is required as the + // `Page.frameRequestedNavigation` event is not emitted for same-document navigations. + __privateAdd(this, _pendingNavigationUrl, void 0); + // Navigation ID is required, as CDP `loaderId` cannot be mapped 1:1 to all the + // navigations (e.g. same document navigations). Updated after each navigation, + // including same-document ones. + __privateAdd(this, _navigationId, (0, uuid_js_1.uuidv4)()); + // When a new navigation is started via `BrowsingContext.navigate` with `wait` set to + // `None`, the command result should have `navigation` value, but mapper does not have + // it yet. This value will be set to `navigationId` after next . + __privateAdd(this, _pendingNavigationId, void 0); + // Set if there is a pending navigation initiated by `BrowsingContext.navigate` command. + // The promise is resolved when the navigation is finished or rejected when canceled. + __privateAdd(this, _pendingCommandNavigation, void 0); + __privateAdd(this, _originalOpener, void 0); + // Set when the user prompt is opened. Required to provide the type in closing event. + __privateAdd(this, _lastUserPromptType, void 0); + __privateAdd(this, _unhandledPromptBehavior, void 0); + __privateSet(this, _cdpTarget, cdpTarget); + __privateSet(this, _id, id); + __privateSet(this, _parentId, parentId); + this.userContext = userContext; + __privateSet(this, _eventManager, eventManager); + __privateSet(this, _browsingContextStorage, browsingContextStorage); + __privateSet(this, _realmStorage, realmStorage); + __privateSet(this, _unhandledPromptBehavior, unhandledPromptBehavior); + __privateSet(this, _logger, logger); + __privateSet(this, _url, url); + __privateSet(this, _originalOpener, originalOpener); + } + static create(id, parentId, userContext, cdpTarget, eventManager, browsingContextStorage, realmStorage, url, originalOpener, unhandledPromptBehavior, logger) { + var _a4; + const context = new _a3(id, parentId, userContext, cdpTarget, eventManager, browsingContextStorage, realmStorage, url, originalOpener, unhandledPromptBehavior, logger); + __privateMethod(_a4 = context, _initListeners, initListeners_fn).call(_a4); + browsingContextStorage.addContext(context); + if (!context.isTopLevelContext()) { + context.parent.addChild(context.id); + } + eventManager.registerPromiseEvent(context.targetUnblockedOrThrow().then(() => { + return { + kind: "success", + value: { + type: "event", + method: protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.ContextCreated, + params: context.serializeToBidiValue() + } + }; + }, (error) => { + return { + kind: "error", + error + }; + }), context.id, protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.ContextCreated); + return context; + } + static getTimestamp() { + return (/* @__PURE__ */ new Date()).getTime(); + } + /** + * @see https://html.spec.whatwg.org/multipage/document-sequences.html#navigable + */ + get navigableId() { + return __privateGet(this, _loaderId); + } + get navigationId() { + return __privateGet(this, _navigationId); + } + dispose(emitContextDestroyed) { + __privateGet(this, _pendingCommandNavigation)?.reject(new protocol_js_1.UnknownErrorException("navigation canceled by context disposal")); + __privateMethod(this, _deleteAllChildren, deleteAllChildren_fn).call(this); + __privateGet(this, _realmStorage).deleteRealms({ + browsingContextId: this.id + }); + if (!this.isTopLevelContext()) { + __privateGet(this.parent, _children).delete(this.id); + } + __privateMethod(this, _failLifecycleIfNotFinished, failLifecycleIfNotFinished_fn).call(this); + if (emitContextDestroyed) { + __privateGet(this, _eventManager).registerEvent({ + type: "event", + method: protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.ContextDestroyed, + params: this.serializeToBidiValue() + }, this.id); + } + __privateGet(this, _eventManager).clearBufferedEvents(this.id); + __privateGet(this, _browsingContextStorage).deleteContextById(this.id); + } + /** Returns the ID of this context. */ + get id() { + return __privateGet(this, _id); + } + /** Returns the parent context ID. */ + get parentId() { + return __privateGet(this, _parentId); + } + /** Sets the parent context ID and updates parent's children. */ + set parentId(parentId) { + var _a4; + if (__privateGet(this, _parentId) !== null) { + (_a4 = __privateGet(this, _logger)) == null ? void 0 : _a4.call(this, log_js_1.LogType.debugError, "Parent context already set"); + return; + } + __privateSet(this, _parentId, parentId); + if (!this.isTopLevelContext()) { + this.parent.addChild(this.id); + } + } + /** Returns the parent context. */ + get parent() { + if (this.parentId === null) { + return null; + } + return __privateGet(this, _browsingContextStorage).getContext(this.parentId); + } + /** Returns all direct children contexts. */ + get directChildren() { + return [...__privateGet(this, _children)].map((id) => __privateGet(this, _browsingContextStorage).getContext(id)); + } + /** Returns all children contexts, flattened. */ + get allChildren() { + const children = this.directChildren; + return children.concat(...children.map((child) => child.allChildren)); + } + /** + * Returns true if this is a top-level context. + * This is the case whenever the parent context ID is null. + */ + isTopLevelContext() { + return __privateGet(this, _parentId) === null; + } + get top() { + let topContext = this; + let parent = topContext.parent; + while (parent) { + topContext = parent; + parent = topContext.parent; + } + return topContext; + } + addChild(childId) { + __privateGet(this, _children).add(childId); + } + get cdpTarget() { + return __privateGet(this, _cdpTarget); + } + updateCdpTarget(cdpTarget) { + __privateSet(this, _cdpTarget, cdpTarget); + __privateMethod(this, _initListeners, initListeners_fn).call(this); + } + get url() { + return __privateGet(this, _url); + } + async lifecycleLoaded() { + await __privateGet(this, _lifecycle).load; + } + async targetUnblockedOrThrow() { + const result = await __privateGet(this, _cdpTarget).unblocked; + if (result.kind === "error") { + throw result.error; + } + } + async getOrCreateSandbox(sandbox) { + if (sandbox === void 0 || sandbox === "") { + return await __privateGet(this, _defaultRealmDeferred); + } + let maybeSandboxes = __privateGet(this, _realmStorage).findRealms({ + browsingContextId: this.id, + sandbox + }); + if (maybeSandboxes.length === 0) { + await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Page.createIsolatedWorld", { + frameId: this.id, + worldName: sandbox + }); + maybeSandboxes = __privateGet(this, _realmStorage).findRealms({ + browsingContextId: this.id, + sandbox + }); + (0, assert_js_1.assert)(maybeSandboxes.length !== 0); + } + return maybeSandboxes[0]; + } + serializeToBidiValue(maxDepth = 0, addParentField = true) { + return { + context: __privateGet(this, _id), + url: this.url, + userContext: this.userContext, + originalOpener: __privateGet(this, _originalOpener) ?? null, + // TODO(#2646): Implement Client Window correctly + clientWindow: "", + children: maxDepth > 0 ? this.directChildren.map((c) => c.serializeToBidiValue(maxDepth - 1, false)) : null, + ...addParentField ? { parent: __privateGet(this, _parentId) } : {} + }; + } + onTargetInfoChanged(params) { + __privateSet(this, _url, params.targetInfo.url); + } + async navigate(url, wait) { + try { + new URL(url); + } catch { + throw new protocol_js_1.InvalidArgumentException(`Invalid URL: ${url}`); + } + __privateGet(this, _pendingCommandNavigation)?.reject(new protocol_js_1.UnknownErrorException("navigation canceled by concurrent navigation")); + await this.targetUnblockedOrThrow(); + __privateSet(this, _pendingNavigationUrl, url); + const navigationId = (0, uuid_js_1.uuidv4)(); + __privateSet(this, _pendingNavigationId, navigationId); + __privateSet(this, _pendingCommandNavigation, new Deferred_js_1.Deferred()); + const cdpNavigatePromise = (async () => { + const cdpNavigateResult2 = await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Page.navigate", { + url, + frameId: this.id + }); + if (cdpNavigateResult2.errorText) { + __privateSet(this, _pendingNavigationUrl, void 0); + __privateGet(this, _eventManager).registerEvent({ + type: "event", + method: protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.NavigationFailed, + params: { + context: this.id, + navigation: navigationId, + timestamp: _a3.getTimestamp(), + url + } + }, this.id); + throw new protocol_js_1.UnknownErrorException(cdpNavigateResult2.errorText); + } + __privateMethod(this, _documentChanged, documentChanged_fn).call(this, cdpNavigateResult2.loaderId); + return cdpNavigateResult2; + })(); + if (wait === "none") { + __privateGet(this, _pendingCommandNavigation).resolve(); + __privateSet(this, _pendingCommandNavigation, void 0); + return { + navigation: navigationId, + url + }; + } + const cdpNavigateResult = await cdpNavigatePromise; + await Promise.race([ + // No `loaderId` means same-document navigation. + __privateMethod(this, _waitNavigation, waitNavigation_fn).call(this, wait, cdpNavigateResult.loaderId === void 0), + // Throw an error if the navigation is canceled. + __privateGet(this, _pendingCommandNavigation) + ]); + __privateGet(this, _pendingCommandNavigation).resolve(); + __privateSet(this, _pendingCommandNavigation, void 0); + return { + navigation: navigationId, + // Url can change due to redirect get the latest one. + url: __privateGet(this, _url) + }; + } + // TODO: support concurrent navigations analogous to `navigate`. + async reload(ignoreCache, wait) { + await this.targetUnblockedOrThrow(); + __privateMethod(this, _resetLifecycleIfFinished, resetLifecycleIfFinished_fn).call(this); + await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Page.reload", { + ignoreCache + }); + switch (wait) { + case "none": + break; + case "interactive": + await __privateGet(this, _lifecycle).DOMContentLoaded; + break; + case "complete": + await __privateGet(this, _lifecycle).load; + break; + } + return { + navigation: __privateGet(this, _navigationId), + url: this.url + }; + } + async setViewport(viewport, devicePixelRatio) { + if (viewport === null && devicePixelRatio === null) { + await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Emulation.clearDeviceMetricsOverride"); + } else { + try { + let appliedViewport; + if (viewport === void 0) { + appliedViewport = __privateGet(this, _previousViewport); + } else if (viewport === null) { + appliedViewport = { + width: 0, + height: 0 + }; + } else { + appliedViewport = viewport; + } + __privateSet(this, _previousViewport, appliedViewport); + await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Emulation.setDeviceMetricsOverride", { + width: __privateGet(this, _previousViewport).width, + height: __privateGet(this, _previousViewport).height, + deviceScaleFactor: devicePixelRatio ? devicePixelRatio : 0, + mobile: false, + dontSetVisibleSize: true + }); + } catch (err) { + if (err.message.startsWith( + // https://crsrc.org/c/content/browser/devtools/protocol/emulation_handler.cc;l=257;drc=2f6eee84cf98d4227e7c41718dd71b82f26d90ff + "Width and height values must be positive" + )) { + throw new protocol_js_1.UnsupportedOperationException("Provided viewport dimensions are not supported"); + } + throw err; + } + } + } + async handleUserPrompt(accept, userText) { + await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Page.handleJavaScriptDialog", { + accept: accept ?? true, + promptText: userText + }); + } + async activate() { + await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Page.bringToFront"); + } + async captureScreenshot(params) { + if (!this.isTopLevelContext()) { + throw new protocol_js_1.UnsupportedOperationException(`Non-top-level 'context' (${params.context}) is currently not supported`); + } + const formatParameters = getImageFormatParameters(params); + await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Page.bringToFront"); + let captureBeyondViewport = false; + let script; + params.origin ??= "viewport"; + switch (params.origin) { + case "document": { + script = String(() => { + const element = document.documentElement; + return { + x: 0, + y: 0, + width: element.scrollWidth, + height: element.scrollHeight + }; + }); + captureBeyondViewport = true; + break; + } + case "viewport": { + script = String(() => { + const viewport = window.visualViewport; + return { + x: viewport.pageLeft, + y: viewport.pageTop, + width: viewport.width, + height: viewport.height + }; + }); + break; + } + } + const realm = await this.getOrCreateSandbox(void 0); + const originResult = await realm.callFunction(script, false); + (0, assert_js_1.assert)(originResult.type === "success"); + const origin = deserializeDOMRect(originResult.result); + (0, assert_js_1.assert)(origin); + let rect = origin; + if (params.clip) { + const clip = params.clip; + if (params.origin === "viewport" && clip.type === "box") { + clip.x += origin.x; + clip.y += origin.y; + } + rect = getIntersectionRect(await __privateMethod(this, _parseRect, parseRect_fn).call(this, clip), origin); + } + if (rect.width === 0 || rect.height === 0) { + throw new protocol_js_1.UnableToCaptureScreenException(`Unable to capture screenshot with zero dimensions: width=${rect.width}, height=${rect.height}`); + } + return await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Page.captureScreenshot", { + clip: { ...rect, scale: 1 }, + ...formatParameters, + captureBeyondViewport + }); + } + async print(params) { + const cdpParams = {}; + if (params.background !== void 0) { + cdpParams.printBackground = params.background; + } + if (params.margin?.bottom !== void 0) { + cdpParams.marginBottom = (0, unitConversions_js_1.inchesFromCm)(params.margin.bottom); + } + if (params.margin?.left !== void 0) { + cdpParams.marginLeft = (0, unitConversions_js_1.inchesFromCm)(params.margin.left); + } + if (params.margin?.right !== void 0) { + cdpParams.marginRight = (0, unitConversions_js_1.inchesFromCm)(params.margin.right); + } + if (params.margin?.top !== void 0) { + cdpParams.marginTop = (0, unitConversions_js_1.inchesFromCm)(params.margin.top); + } + if (params.orientation !== void 0) { + cdpParams.landscape = params.orientation === "landscape"; + } + if (params.page?.height !== void 0) { + cdpParams.paperHeight = (0, unitConversions_js_1.inchesFromCm)(params.page.height); + } + if (params.page?.width !== void 0) { + cdpParams.paperWidth = (0, unitConversions_js_1.inchesFromCm)(params.page.width); + } + if (params.pageRanges !== void 0) { + for (const range of params.pageRanges) { + if (typeof range === "number") { + continue; + } + const rangeParts = range.split("-"); + if (rangeParts.length < 1 || rangeParts.length > 2) { + throw new protocol_js_1.InvalidArgumentException(`Invalid page range: ${range} is not a valid integer range.`); + } + if (rangeParts.length === 1) { + void parseInteger(rangeParts[0] ?? ""); + continue; + } + let lowerBound; + let upperBound; + const [rangeLowerPart = "", rangeUpperPart = ""] = rangeParts; + if (rangeLowerPart === "") { + lowerBound = 1; + } else { + lowerBound = parseInteger(rangeLowerPart); + } + if (rangeUpperPart === "") { + upperBound = Number.MAX_SAFE_INTEGER; + } else { + upperBound = parseInteger(rangeUpperPart); + } + if (lowerBound > upperBound) { + throw new protocol_js_1.InvalidArgumentException(`Invalid page range: ${rangeLowerPart} > ${rangeUpperPart}`); + } + } + cdpParams.pageRanges = params.pageRanges.join(","); + } + if (params.scale !== void 0) { + cdpParams.scale = params.scale; + } + if (params.shrinkToFit !== void 0) { + cdpParams.preferCSSPageSize = !params.shrinkToFit; + } + try { + const result = await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Page.printToPDF", cdpParams); + return { + data: result.data + }; + } catch (error) { + if (error.message === "invalid print parameters: content area is empty") { + throw new protocol_js_1.UnsupportedOperationException(error.message); + } + throw error; + } + } + async close() { + await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Page.close"); + } + async traverseHistory(delta) { + if (delta === 0) { + return; + } + const history = await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Page.getNavigationHistory"); + const entry = history.entries[history.currentIndex + delta]; + if (!entry) { + throw new protocol_js_1.NoSuchHistoryEntryException(`No history entry at delta ${delta}`); + } + await __privateGet(this, _cdpTarget).cdpClient.sendCommand("Page.navigateToHistoryEntry", { + entryId: entry.id + }); + } + async toggleModulesIfNeeded() { + await Promise.all([ + __privateGet(this, _cdpTarget).toggleNetworkIfNeeded(), + __privateGet(this, _cdpTarget).toggleDeviceAccessIfNeeded() + ]); + } + async locateNodes(params) { + return await __privateMethod(this, _locateNodesByLocator, locateNodesByLocator_fn).call(this, await __privateGet(this, _defaultRealmDeferred), params.locator, params.startNodes ?? [], params.maxNodeCount, params.serializationOptions); + } + }; + _id = new WeakMap(); + _parentId = new WeakMap(); + _children = new WeakMap(); + _browsingContextStorage = new WeakMap(); + _lifecycle = new WeakMap(); + _navigation = new WeakMap(); + _url = new WeakMap(); + _eventManager = new WeakMap(); + _realmStorage = new WeakMap(); + _loaderId = new WeakMap(); + _cdpTarget = new WeakMap(); + _defaultRealmDeferred = new WeakMap(); + _logger = new WeakMap(); + _previousViewport = new WeakMap(); + _pendingNavigationUrl = new WeakMap(); + _navigationId = new WeakMap(); + _pendingNavigationId = new WeakMap(); + _pendingCommandNavigation = new WeakMap(); + _originalOpener = new WeakMap(); + _lastUserPromptType = new WeakMap(); + _unhandledPromptBehavior = new WeakMap(); + _deleteAllChildren = new WeakSet(); + deleteAllChildren_fn = function(emitContextDestroyed = false) { + this.directChildren.map((child) => child.dispose(emitContextDestroyed)); + }; + _initListeners = new WeakSet(); + initListeners_fn = function() { + __privateGet(this, _cdpTarget).cdpClient.on("Page.frameNavigated", (params) => { + if (this.id !== params.frame.id) { + return; + } + __privateSet(this, _url, params.frame.url + (params.frame.urlFragment ?? "")); + __privateSet(this, _pendingNavigationUrl, void 0); + __privateMethod(this, _deleteAllChildren, deleteAllChildren_fn).call(this); + }); + __privateGet(this, _cdpTarget).cdpClient.on("Page.navigatedWithinDocument", (params) => { + if (this.id !== params.frameId) { + return; + } + __privateSet(this, _pendingNavigationUrl, void 0); + const timestamp = _a3.getTimestamp(); + __privateSet(this, _url, params.url); + __privateGet(this, _navigation).withinDocument.resolve(); + __privateGet(this, _eventManager).registerEvent({ + type: "event", + method: protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.FragmentNavigated, + params: { + context: this.id, + navigation: __privateGet(this, _navigationId), + timestamp, + url: __privateGet(this, _url) + } + }, this.id); + }); + __privateGet(this, _cdpTarget).cdpClient.on("Page.frameStartedLoading", (params) => { + if (this.id !== params.frameId) { + return; + } + __privateSet(this, _navigationId, __privateGet(this, _pendingNavigationId) ?? (0, uuid_js_1.uuidv4)()); + __privateSet(this, _pendingNavigationId, void 0); + __privateGet(this, _eventManager).registerEvent({ + type: "event", + method: protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.NavigationStarted, + params: { + context: this.id, + navigation: __privateGet(this, _navigationId), + timestamp: _a3.getTimestamp(), + // The URL of the navigation that is currently in progress. Although the URL + // is not yet known in case of user-initiated navigations, it is possible to + // provide the URL in case of BiDi-initiated navigations. + // TODO: provide proper URL in case of user-initiated navigations. + url: __privateGet(this, _pendingNavigationUrl) ?? "UNKNOWN" + } + }, this.id); + }); + __privateGet(this, _cdpTarget).cdpClient.on("Page.frameScheduledNavigation", (params) => { + if (this.id !== params.frameId) { + return; + } + __privateSet(this, _pendingNavigationUrl, params.url); + }); + __privateGet(this, _cdpTarget).cdpClient.on("Page.frameRequestedNavigation", (params) => { + if (this.id !== params.frameId) { + return; + } + __privateGet(this, _pendingCommandNavigation)?.reject(new protocol_js_1.UnknownErrorException(`navigation canceled, as new navigation is requested by ${params.reason}`)); + __privateSet(this, _pendingNavigationUrl, params.url); + }); + __privateGet(this, _cdpTarget).cdpClient.on("Page.lifecycleEvent", (params) => { + if (this.id !== params.frameId) { + return; + } + if (params.name === "init") { + __privateMethod(this, _documentChanged, documentChanged_fn).call(this, params.loaderId); + return; + } + if (params.name === "commit") { + __privateSet(this, _loaderId, params.loaderId); + return; + } + if (!__privateGet(this, _loaderId)) { + __privateSet(this, _loaderId, params.loaderId); + } + if (params.loaderId !== __privateGet(this, _loaderId)) { + return; + } + const timestamp = _a3.getTimestamp(); + switch (params.name) { + case "DOMContentLoaded": + __privateGet(this, _eventManager).registerEvent({ + type: "event", + method: protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.DomContentLoaded, + params: { + context: this.id, + navigation: __privateGet(this, _navigationId), + timestamp, + url: __privateGet(this, _url) + } + }, this.id); + __privateGet(this, _lifecycle).DOMContentLoaded.resolve(); + break; + case "load": + __privateGet(this, _eventManager).registerEvent({ + type: "event", + method: protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.Load, + params: { + context: this.id, + navigation: __privateGet(this, _navigationId), + timestamp, + url: __privateGet(this, _url) + } + }, this.id); + __privateGet(this, _lifecycle).load.resolve(); + break; + } + }); + __privateGet(this, _cdpTarget).cdpClient.on("Runtime.executionContextCreated", (params) => { + var _a4; + const { auxData, name, uniqueId, id } = params.context; + if (!auxData || auxData.frameId !== this.id) { + return; + } + let origin; + let sandbox; + switch (auxData.type) { + case "isolated": + sandbox = name; + if (!__privateGet(this, _defaultRealmDeferred).isFinished) { + (_a4 = __privateGet(this, _logger)) == null ? void 0 : _a4.call(this, log_js_1.LogType.debugError, "Unexpectedly, isolated realm created before the default one"); + } + origin = __privateGet(this, _defaultRealmDeferred).isFinished ? __privateGet(this, _defaultRealmDeferred).result.origin : ( + // This fallback is not expected to be ever reached. + "" + ); + break; + case "default": + origin = serializeOrigin(params.context.origin); + break; + default: + return; + } + const realm = new WindowRealm_js_1.WindowRealm(this.id, __privateGet(this, _browsingContextStorage), __privateGet(this, _cdpTarget).cdpClient, __privateGet(this, _eventManager), id, __privateGet(this, _logger), origin, uniqueId, __privateGet(this, _realmStorage), sandbox); + if (auxData.isDefault) { + __privateGet(this, _defaultRealmDeferred).resolve(realm); + void Promise.all(__privateGet(this, _cdpTarget).getChannels().map((channel) => channel.startListenerFromWindow(realm, __privateGet(this, _eventManager)))); + } + }); + __privateGet(this, _cdpTarget).cdpClient.on("Runtime.executionContextDestroyed", (params) => { + if (__privateGet(this, _defaultRealmDeferred).isFinished && __privateGet(this, _defaultRealmDeferred).result.executionContextId === params.executionContextId) { + __privateSet(this, _defaultRealmDeferred, new Deferred_js_1.Deferred()); + } + __privateGet(this, _realmStorage).deleteRealms({ + cdpSessionId: __privateGet(this, _cdpTarget).cdpSessionId, + executionContextId: params.executionContextId + }); + }); + __privateGet(this, _cdpTarget).cdpClient.on("Runtime.executionContextsCleared", () => { + if (!__privateGet(this, _defaultRealmDeferred).isFinished) { + __privateGet(this, _defaultRealmDeferred).reject(new protocol_js_1.UnknownErrorException("execution contexts cleared")); + } + __privateSet(this, _defaultRealmDeferred, new Deferred_js_1.Deferred()); + __privateGet(this, _realmStorage).deleteRealms({ + cdpSessionId: __privateGet(this, _cdpTarget).cdpSessionId + }); + }); + __privateGet(this, _cdpTarget).cdpClient.on("Page.javascriptDialogClosed", (params) => { + var _a4; + const accepted = params.result; + if (__privateGet(this, _lastUserPromptType) === void 0) { + (_a4 = __privateGet(this, _logger)) == null ? void 0 : _a4.call(this, log_js_1.LogType.debugError, "Unexpectedly no opening prompt event before closing one"); + } + __privateGet(this, _eventManager).registerEvent({ + type: "event", + method: protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.UserPromptClosed, + params: { + context: this.id, + accepted, + // `lastUserPromptType` should never be undefined here, so fallback to + // `UNKNOWN`. The fallback is required to prevent tests from hanging while + // waiting for the closing event. The cast is required, as the `UNKNOWN` value + // is not standard. + type: __privateGet(this, _lastUserPromptType) ?? "UNKNOWN", + userText: accepted && params.userInput ? params.userInput : void 0 + } + }, this.id); + __privateSet(this, _lastUserPromptType, void 0); + }); + __privateGet(this, _cdpTarget).cdpClient.on("Page.javascriptDialogOpening", (params) => { + var _a4; + const promptType = __privateMethod(_a4 = _a3, _getPromptType, getPromptType_fn).call(_a4, params.type); + __privateSet(this, _lastUserPromptType, promptType); + const promptHandler = __privateMethod(this, _getPromptHandler, getPromptHandler_fn).call(this, promptType); + __privateGet(this, _eventManager).registerEvent({ + type: "event", + method: protocol_js_1.ChromiumBidi.BrowsingContext.EventNames.UserPromptOpened, + params: { + context: this.id, + handler: promptHandler, + type: promptType, + message: params.message, + ...params.type === "prompt" ? { defaultValue: params.defaultPrompt } : {} + } + }, this.id); + switch (promptHandler) { + case "accept": + void this.handleUserPrompt(true); + break; + case "dismiss": + void this.handleUserPrompt(false); + break; + case "ignore": + break; + } + }); + }; + _getPromptType = new WeakSet(); + getPromptType_fn = function(cdpType) { + switch (cdpType) { + case "alert": + return "alert"; + case "beforeunload": + return "beforeunload"; + case "confirm": + return "confirm"; + case "prompt": + return "prompt"; + } + }; + _getPromptHandler = new WeakSet(); + getPromptHandler_fn = function(promptType) { + const defaultPromptHandler = "dismiss"; + switch (promptType) { + case "alert": + return __privateGet(this, _unhandledPromptBehavior)?.alert ?? __privateGet(this, _unhandledPromptBehavior)?.default ?? defaultPromptHandler; + case "beforeunload": + return __privateGet(this, _unhandledPromptBehavior)?.beforeUnload ?? __privateGet(this, _unhandledPromptBehavior)?.default ?? "accept"; + case "confirm": + return __privateGet(this, _unhandledPromptBehavior)?.confirm ?? __privateGet(this, _unhandledPromptBehavior)?.default ?? defaultPromptHandler; + case "prompt": + return __privateGet(this, _unhandledPromptBehavior)?.prompt ?? __privateGet(this, _unhandledPromptBehavior)?.default ?? defaultPromptHandler; + } + }; + _documentChanged = new WeakSet(); + documentChanged_fn = function(loaderId) { + var _a4; + if (loaderId === void 0 || __privateGet(this, _loaderId) === loaderId) { + if (__privateGet(this, _navigation).withinDocument.isFinished) { + __privateGet(this, _navigation).withinDocument = new Deferred_js_1.Deferred(); + } else { + (_a4 = __privateGet(this, _logger)) == null ? void 0 : _a4.call(this, _a3.LOGGER_PREFIX, "Document changed (navigatedWithinDocument)"); + } + return; + } + __privateMethod(this, _resetLifecycleIfFinished, resetLifecycleIfFinished_fn).call(this); + __privateSet(this, _loaderId, loaderId); + __privateMethod(this, _deleteAllChildren, deleteAllChildren_fn).call(this, true); + }; + _resetLifecycleIfFinished = new WeakSet(); + resetLifecycleIfFinished_fn = function() { + var _a4, _b; + if (__privateGet(this, _lifecycle).DOMContentLoaded.isFinished) { + __privateGet(this, _lifecycle).DOMContentLoaded = new Deferred_js_1.Deferred(); + } else { + (_a4 = __privateGet(this, _logger)) == null ? void 0 : _a4.call(this, _a3.LOGGER_PREFIX, "Document changed (DOMContentLoaded)"); + } + if (__privateGet(this, _lifecycle).load.isFinished) { + __privateGet(this, _lifecycle).load = new Deferred_js_1.Deferred(); + } else { + (_b = __privateGet(this, _logger)) == null ? void 0 : _b.call(this, _a3.LOGGER_PREFIX, "Document changed (load)"); + } + }; + _failLifecycleIfNotFinished = new WeakSet(); + failLifecycleIfNotFinished_fn = function() { + if (!__privateGet(this, _lifecycle).DOMContentLoaded.isFinished) { + __privateGet(this, _lifecycle).DOMContentLoaded.reject(new protocol_js_1.UnknownErrorException("navigation canceled")); + } + if (!__privateGet(this, _lifecycle).load.isFinished) { + __privateGet(this, _lifecycle).load.reject(new protocol_js_1.UnknownErrorException("navigation canceled")); + } + }; + _waitNavigation = new WeakSet(); + waitNavigation_fn = async function(wait, withinDocument) { + if (withinDocument) { + await __privateGet(this, _navigation).withinDocument; + return; + } + switch (wait) { + case "none": + return; + case "interactive": + await __privateGet(this, _lifecycle).DOMContentLoaded; + return; + case "complete": + await __privateGet(this, _lifecycle).load; + return; + } + }; + _parseRect = new WeakSet(); + parseRect_fn = async function(clip) { + switch (clip.type) { + case "box": + return { x: clip.x, y: clip.y, width: clip.width, height: clip.height }; + case "element": { + const sandbox = await this.getOrCreateSandbox(void 0); + const result = await sandbox.callFunction(String((element) => { + return element instanceof Element; + }), false, { type: "undefined" }, [clip.element]); + if (result.type === "exception") { + throw new protocol_js_1.NoSuchElementException(`Element '${clip.element.sharedId}' was not found`); + } + (0, assert_js_1.assert)(result.result.type === "boolean"); + if (!result.result.value) { + throw new protocol_js_1.NoSuchElementException(`Node '${clip.element.sharedId}' is not an Element`); + } + { + const result2 = await sandbox.callFunction(String((element) => { + const rect2 = element.getBoundingClientRect(); + return { + x: rect2.x, + y: rect2.y, + height: rect2.height, + width: rect2.width + }; + }), false, { type: "undefined" }, [clip.element]); + (0, assert_js_1.assert)(result2.type === "success"); + const rect = deserializeDOMRect(result2.result); + if (!rect) { + throw new protocol_js_1.UnableToCaptureScreenException(`Could not get bounding box for Element '${clip.element.sharedId}'`); + } + return rect; + } + } + } + }; + _getLocatorDelegate = new WeakSet(); + getLocatorDelegate_fn = async function(realm, locator, maxNodeCount, startNodes) { + switch (locator.type) { + case "css": + return { + functionDeclaration: String((cssSelector, maxNodeCount2, ...startNodes2) => { + const locateNodesUsingCss = (element) => { + if (!(element instanceof HTMLElement || element instanceof Document || element instanceof DocumentFragment)) { + throw new Error("startNodes in css selector should be HTMLElement, Document or DocumentFragment"); + } + return [...element.querySelectorAll(cssSelector)]; + }; + startNodes2 = startNodes2.length > 0 ? startNodes2 : [document]; + const returnedNodes = startNodes2.map((startNode) => ( + // TODO: stop search early if `maxNodeCount` is reached. + locateNodesUsingCss(startNode) + )).flat(1); + return maxNodeCount2 === 0 ? returnedNodes : returnedNodes.slice(0, maxNodeCount2); + }), + argumentsLocalValues: [ + // `cssSelector` + { type: "string", value: locator.value }, + // `maxNodeCount` with `0` means no limit. + { type: "number", value: maxNodeCount ?? 0 }, + // `startNodes` + ...startNodes + ] + }; + case "xpath": + return { + functionDeclaration: String((xPathSelector, maxNodeCount2, ...startNodes2) => { + const evaluator = new XPathEvaluator(); + const expression = evaluator.createExpression(xPathSelector); + const locateNodesUsingXpath = (element) => { + const xPathResult = expression.evaluate(element, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE); + const returnedNodes2 = []; + for (let i = 0; i < xPathResult.snapshotLength; i++) { + returnedNodes2.push(xPathResult.snapshotItem(i)); + } + return returnedNodes2; + }; + startNodes2 = startNodes2.length > 0 ? startNodes2 : [document]; + const returnedNodes = startNodes2.map((startNode) => ( + // TODO: stop search early if `maxNodeCount` is reached. + locateNodesUsingXpath(startNode) + )).flat(1); + return maxNodeCount2 === 0 ? returnedNodes : returnedNodes.slice(0, maxNodeCount2); + }), + argumentsLocalValues: [ + // `xPathSelector` + { type: "string", value: locator.value }, + // `maxNodeCount` with `0` means no limit. + { type: "number", value: maxNodeCount ?? 0 }, + // `startNodes` + ...startNodes + ] + }; + case "innerText": + if (locator.value === "") { + throw new protocol_js_1.InvalidSelectorException("innerText locator cannot be empty"); + } + return { + functionDeclaration: String((innerTextSelector, fullMatch, ignoreCase, maxNodeCount2, maxDepth, ...startNodes2) => { + const searchText = ignoreCase ? innerTextSelector.toUpperCase() : innerTextSelector; + const locateNodesUsingInnerText = (node, currentMaxDepth) => { + const returnedNodes2 = []; + if (node instanceof DocumentFragment || node instanceof Document) { + const children = [...node.children]; + children.forEach((child) => ( + // `currentMaxDepth` is not decremented intentionally according to + // https://github.com/w3c/webdriver-bidi/pull/713. + returnedNodes2.push(...locateNodesUsingInnerText(child, currentMaxDepth)) + )); + return returnedNodes2; + } + if (!(node instanceof HTMLElement)) { + return []; + } + const element = node; + const nodeInnerText = ignoreCase ? element.innerText?.toUpperCase() : element.innerText; + if (!nodeInnerText.includes(searchText)) { + return []; + } + const childNodes = []; + for (const child of element.children) { + if (child instanceof HTMLElement) { + childNodes.push(child); + } + } + if (childNodes.length === 0) { + if (fullMatch && nodeInnerText === searchText) { + returnedNodes2.push(element); + } else { + if (!fullMatch) { + returnedNodes2.push(element); + } + } + } else { + const childNodeMatches = ( + // Don't search deeper if `maxDepth` is reached. + currentMaxDepth <= 0 ? [] : childNodes.map((child) => locateNodesUsingInnerText(child, currentMaxDepth - 1)).flat(1) + ); + if (childNodeMatches.length === 0) { + if (!fullMatch || nodeInnerText === searchText) { + returnedNodes2.push(element); + } + } else { + returnedNodes2.push(...childNodeMatches); + } + } + return returnedNodes2; + }; + startNodes2 = startNodes2.length > 0 ? startNodes2 : [document]; + const returnedNodes = startNodes2.map((startNode) => ( + // TODO: stop search early if `maxNodeCount` is reached. + locateNodesUsingInnerText(startNode, maxDepth) + )).flat(1); + return maxNodeCount2 === 0 ? returnedNodes : returnedNodes.slice(0, maxNodeCount2); + }), + argumentsLocalValues: [ + // `innerTextSelector` + { type: "string", value: locator.value }, + // `fullMatch` with default `true`. + { type: "boolean", value: locator.matchType !== "partial" }, + // `ignoreCase` with default `false`. + { type: "boolean", value: locator.ignoreCase === true }, + // `maxNodeCount` with `0` means no limit. + { type: "number", value: maxNodeCount ?? 0 }, + // `maxDepth` with default `1000` (same as default full serialization depth). + { type: "number", value: locator.maxDepth ?? 1e3 }, + // `startNodes` + ...startNodes + ] + }; + case "accessibility": { + if (!locator.value.name && !locator.value.role) { + throw new protocol_js_1.InvalidSelectorException("Either name or role has to be specified"); + } + await Promise.all([ + __privateGet(this, _cdpTarget).cdpClient.sendCommand("Accessibility.enable"), + __privateGet(this, _cdpTarget).cdpClient.sendCommand("Accessibility.getRootAXNode") + ]); + const bindings = await realm.evaluate( + /* expression=*/ + "({getAccessibleName, getAccessibleRole})", + /* awaitPromise=*/ + false, + "root", + /* serializationOptions= */ + void 0, + /* userActivation=*/ + false, + /* includeCommandLineApi=*/ + true + ); + if (bindings.type !== "success") { + throw new Error("Could not get bindings"); + } + if (bindings.result.type !== "object") { + throw new Error("Could not get bindings"); + } + return { + functionDeclaration: String((name, role, bindings2, maxNodeCount2, ...startNodes2) => { + const returnedNodes = []; + let aborted = false; + function collect(contextNodes, selector) { + if (aborted) { + return; + } + for (const contextNode of contextNodes) { + let match = true; + if (selector.role) { + const role2 = bindings2.getAccessibleRole(contextNode); + if (selector.role !== role2) { + match = false; + } + } + if (selector.name) { + const name2 = bindings2.getAccessibleName(contextNode); + if (selector.name !== name2) { + match = false; + } + } + if (match) { + if (maxNodeCount2 !== 0 && returnedNodes.length === maxNodeCount2) { + aborted = true; + break; + } + returnedNodes.push(contextNode); + } + const childNodes = []; + for (const child of contextNode.children) { + if (child instanceof HTMLElement) { + childNodes.push(child); + } + } + collect(childNodes, selector); + } + } + startNodes2 = startNodes2.length > 0 ? startNodes2 : Array.from(document.documentElement.children).filter((c) => c instanceof HTMLElement); + collect(startNodes2, { + role, + name + }); + return returnedNodes; + }), + argumentsLocalValues: [ + // `name` + { type: "string", value: locator.value.name || "" }, + // `role` + { type: "string", value: locator.value.role || "" }, + // `bindings`. + { handle: bindings.result.handle }, + // `maxNodeCount` with `0` means no limit. + { type: "number", value: maxNodeCount ?? 0 }, + // `startNodes` + ...startNodes + ] + }; + } + } + }; + _locateNodesByLocator = new WeakSet(); + locateNodesByLocator_fn = async function(realm, locator, startNodes, maxNodeCount, serializationOptions) { + var _a4; + const locatorDelegate = await __privateMethod(this, _getLocatorDelegate, getLocatorDelegate_fn).call(this, realm, locator, maxNodeCount, startNodes); + serializationOptions = { + ...serializationOptions, + // The returned object is an array of nodes, so no need in deeper JS serialization. + maxObjectDepth: 1 + }; + const locatorResult = await realm.callFunction(locatorDelegate.functionDeclaration, false, { type: "undefined" }, locatorDelegate.argumentsLocalValues, "none", serializationOptions); + if (locatorResult.type !== "success") { + (_a4 = __privateGet(this, _logger)) == null ? void 0 : _a4.call(this, _a3.LOGGER_PREFIX, "Failed locateNodesByLocator", locatorResult); + if ( + // CSS selector. + locatorResult.exceptionDetails.text?.endsWith("is not a valid selector.") || // XPath selector. + locatorResult.exceptionDetails.text?.endsWith("is not a valid XPath expression.") + ) { + throw new protocol_js_1.InvalidSelectorException(`Not valid selector ${typeof locator.value === "string" ? locator.value : JSON.stringify(locator.value)}`); + } + if (locatorResult.exceptionDetails.text === "Error: startNodes in css selector should be HTMLElement, Document or DocumentFragment") { + throw new protocol_js_1.InvalidArgumentException("startNodes in css selector should be HTMLElement, Document or DocumentFragment"); + } + throw new protocol_js_1.UnknownErrorException(`Unexpected error in selector script: ${locatorResult.exceptionDetails.text}`); + } + if (locatorResult.result.type !== "array") { + throw new protocol_js_1.UnknownErrorException(`Unexpected selector script result type: ${locatorResult.result.type}`); + } + const nodes = locatorResult.result.value.map((value) => { + if (value.type !== "node") { + throw new protocol_js_1.UnknownErrorException(`Unexpected selector script result element: ${value.type}`); + } + return value; + }); + return { nodes }; + }; + __privateAdd(BrowsingContextImpl, _getPromptType); + __publicField(BrowsingContextImpl, "LOGGER_PREFIX", `${log_js_1.LogType.debug}:browsingContext`); + exports.BrowsingContextImpl = BrowsingContextImpl; + _a3 = BrowsingContextImpl; + function serializeOrigin(origin) { + if (["://", ""].includes(origin)) { + origin = "null"; + } + return origin; + } + function getImageFormatParameters(params) { + const { quality, type } = params.format ?? { + type: "image/png" + }; + switch (type) { + case "image/png": { + return { format: "png" }; + } + case "image/jpeg": { + return { + format: "jpeg", + ...quality === void 0 ? {} : { quality: Math.round(quality * 100) } + }; + } + case "image/webp": { + return { + format: "webp", + ...quality === void 0 ? {} : { quality: Math.round(quality * 100) } + }; + } + } + throw new protocol_js_1.InvalidArgumentException(`Image format '${type}' is not a supported format`); + } + function deserializeDOMRect(result) { + if (result.type !== "object" || result.value === void 0) { + return; + } + const x = result.value.find(([key]) => { + return key === "x"; + })?.[1]; + const y = result.value.find(([key]) => { + return key === "y"; + })?.[1]; + const height = result.value.find(([key]) => { + return key === "height"; + })?.[1]; + const width = result.value.find(([key]) => { + return key === "width"; + })?.[1]; + if (x?.type !== "number" || y?.type !== "number" || height?.type !== "number" || width?.type !== "number") { + return; + } + return { + x: x.value, + y: y.value, + width: width.value, + height: height.value + }; + } + function normalizeRect(box) { + return { + ...box.width < 0 ? { + x: box.x + box.width, + width: -box.width + } : { + x: box.x, + width: box.width + }, + ...box.height < 0 ? { + y: box.y + box.height, + height: -box.height + } : { + y: box.y, + height: box.height + } + }; + } + function getIntersectionRect(first2, second) { + first2 = normalizeRect(first2); + second = normalizeRect(second); + const x = Math.max(first2.x, second.x); + const y = Math.max(first2.y, second.y); + return { + x, + y, + width: Math.max(Math.min(first2.x + first2.width, second.x + second.width) - x, 0), + height: Math.max(Math.min(first2.y + first2.height, second.y + second.height) - y, 0) + }; + } + function parseInteger(value) { + value = value.trim(); + if (!/^[0-9]+$/.test(value)) { + throw new protocol_js_1.InvalidArgumentException(`Invalid integer: ${value}`); + } + return parseInt(value); + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/WorkerRealm.js +var require_WorkerRealm = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/WorkerRealm.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.WorkerRealm = void 0; + var Realm_js_1 = require_Realm(); + var WorkerRealm = class extends Realm_js_1.Realm { + #realmType; + #ownerRealms; + constructor(cdpClient, eventManager, executionContextId, logger, origin, ownerRealms, realmId, realmStorage, realmType) { + super(cdpClient, eventManager, executionContextId, logger, origin, realmId, realmStorage); + this.#ownerRealms = ownerRealms; + this.#realmType = realmType; + this.initialize(); + } + get associatedBrowsingContexts() { + return this.#ownerRealms.flatMap((realm) => realm.associatedBrowsingContexts); + } + get realmType() { + return this.#realmType; + } + get source() { + return { + realm: this.realmId, + // This is a hack to make Puppeteer able to track workers. + // TODO: remove after Puppeteer tracks workers by owners and use the base version. + context: this.associatedBrowsingContexts[0]?.id + }; + } + get realmInfo() { + const owners = this.#ownerRealms.map((realm) => realm.realmId); + const { realmType } = this; + switch (realmType) { + case "dedicated-worker": { + const owner = owners[0]; + if (owner === void 0 || owners.length !== 1) { + throw new Error("Dedicated worker must have exactly one owner"); + } + return { + ...this.baseInfo, + type: realmType, + owners: [owner] + }; + } + case "service-worker": + case "shared-worker": { + return { + ...this.baseInfo, + type: realmType + }; + } + } + } + }; + exports.WorkerRealm = WorkerRealm; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/log/logHelper.js +var require_logHelper = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/log/logHelper.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.logMessageFormatter = logMessageFormatter; + exports.getRemoteValuesText = getRemoteValuesText; + var assert_js_1 = require_assert(); + var specifiers = ["%s", "%d", "%i", "%f", "%o", "%O", "%c"]; + function isFormatSpecifier(str) { + return specifiers.some((spec) => str.includes(spec)); + } + function logMessageFormatter(args) { + let output = ""; + const argFormat = args[0].value.toString(); + const argValues = args.slice(1, void 0); + const tokens = argFormat.split(new RegExp(specifiers.map((spec) => `(${spec})`).join("|"), "g")); + for (const token of tokens) { + if (token === void 0 || token === "") { + continue; + } + if (isFormatSpecifier(token)) { + const arg = argValues.shift(); + (0, assert_js_1.assert)(arg, `Less value is provided: "${getRemoteValuesText(args, false)}"`); + if (token === "%s") { + output += stringFromArg(arg); + } else if (token === "%d" || token === "%i") { + if (arg.type === "bigint" || arg.type === "number" || arg.type === "string") { + output += parseInt(arg.value.toString(), 10); + } else { + output += "NaN"; + } + } else if (token === "%f") { + if (arg.type === "bigint" || arg.type === "number" || arg.type === "string") { + output += parseFloat(arg.value.toString()); + } else { + output += "NaN"; + } + } else { + output += toJson(arg); + } + } else { + output += token; + } + } + if (argValues.length > 0) { + throw new Error(`More value is provided: "${getRemoteValuesText(args, false)}"`); + } + return output; + } + function toJson(arg) { + if (arg.type !== "array" && arg.type !== "bigint" && arg.type !== "date" && arg.type !== "number" && arg.type !== "object" && arg.type !== "string") { + return stringFromArg(arg); + } + if (arg.type === "bigint") { + return `${arg.value.toString()}n`; + } + if (arg.type === "number") { + return arg.value.toString(); + } + if (["date", "string"].includes(arg.type)) { + return JSON.stringify(arg.value); + } + if (arg.type === "object") { + return `{${arg.value.map((pair) => { + return `${JSON.stringify(pair[0])}:${toJson(pair[1])}`; + }).join(",")}}`; + } + if (arg.type === "array") { + return `[${arg.value?.map((val) => toJson(val)).join(",") ?? ""}]`; + } + throw Error(`Invalid value type: ${arg}`); + } + function stringFromArg(arg) { + if (!Object.hasOwn(arg, "value")) { + return arg.type; + } + switch (arg.type) { + case "string": + case "number": + case "boolean": + case "bigint": + return String(arg.value); + case "regexp": + return `/${arg.value.pattern}/${arg.value.flags ?? ""}`; + case "date": + return new Date(arg.value).toString(); + case "object": + return `Object(${arg.value?.length ?? ""})`; + case "array": + return `Array(${arg.value?.length ?? ""})`; + case "map": + return `Map(${arg.value?.length})`; + case "set": + return `Set(${arg.value?.length})`; + default: + return arg.type; + } + } + function getRemoteValuesText(args, formatText) { + const arg = args[0]; + if (!arg) { + return ""; + } + if (arg.type === "string" && isFormatSpecifier(arg.value.toString()) && formatText) { + return logMessageFormatter(args); + } + return args.map((arg2) => { + return stringFromArg(arg2); + }).join(" "); + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/log/LogManager.js +var require_LogManager = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/log/LogManager.js"(exports) { + "use strict"; + init_cjs_shim(); + var _a3; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.LogManager = void 0; + var protocol_js_1 = require_protocol(); + var log_js_1 = require_log(); + var logHelper_js_1 = require_logHelper(); + function getBidiStackTrace(cdpStackTrace) { + const stackFrames = cdpStackTrace?.callFrames.map((callFrame) => { + return { + columnNumber: callFrame.columnNumber, + functionName: callFrame.functionName, + lineNumber: callFrame.lineNumber, + url: callFrame.url + }; + }); + return stackFrames ? { callFrames: stackFrames } : void 0; + } + function getLogLevel(consoleApiType) { + if (["error", "assert"].includes(consoleApiType)) { + return "error"; + } + if (["debug", "trace"].includes(consoleApiType)) { + return "debug"; + } + if (["warn", "warning"].includes(consoleApiType)) { + return "warn"; + } + return "info"; + } + function getLogMethod(consoleApiType) { + switch (consoleApiType) { + case "warning": + return "warn"; + case "startGroup": + return "group"; + case "startGroupCollapsed": + return "groupCollapsed"; + case "endGroup": + return "groupEnd"; + } + return consoleApiType; + } + var _eventManager, _realmStorage, _cdpTarget, _logger, _heuristicSerializeArg, heuristicSerializeArg_fn, _initializeEntryAddedEventListener, initializeEntryAddedEventListener_fn, _getExceptionText, getExceptionText_fn; + var LogManager = class { + constructor(cdpTarget, realmStorage, eventManager, logger) { + /** + * Heuristic serialization of CDP remote object. If possible, return the BiDi value + * without deep serialization. + */ + __privateAdd(this, _heuristicSerializeArg); + __privateAdd(this, _initializeEntryAddedEventListener); + __privateAdd(this, _eventManager, void 0); + __privateAdd(this, _realmStorage, void 0); + __privateAdd(this, _cdpTarget, void 0); + __privateAdd(this, _logger, void 0); + __privateSet(this, _cdpTarget, cdpTarget); + __privateSet(this, _realmStorage, realmStorage); + __privateSet(this, _eventManager, eventManager); + __privateSet(this, _logger, logger); + } + static create(cdpTarget, realmStorage, eventManager, logger) { + var _a4; + const logManager = new _a3(cdpTarget, realmStorage, eventManager, logger); + __privateMethod(_a4 = logManager, _initializeEntryAddedEventListener, initializeEntryAddedEventListener_fn).call(_a4); + return logManager; + } + }; + _eventManager = new WeakMap(); + _realmStorage = new WeakMap(); + _cdpTarget = new WeakMap(); + _logger = new WeakMap(); + _heuristicSerializeArg = new WeakSet(); + heuristicSerializeArg_fn = async function(arg, realm) { + switch (arg.type) { + case "undefined": + return { type: "undefined" }; + case "boolean": + return { type: "boolean", value: arg.value }; + case "string": + return { type: "string", value: arg.value }; + case "number": + return { type: "number", value: arg.unserializableValue ?? arg.value }; + case "bigint": + if (arg.unserializableValue !== void 0 && arg.unserializableValue[arg.unserializableValue.length - 1] === "n") { + return { + type: arg.type, + value: arg.unserializableValue.slice(0, -1) + }; + } + break; + case "object": + if (arg.subtype === "null") { + return { type: "null" }; + } + break; + default: + break; + } + return await realm.serializeCdpObject( + arg, + "none" + /* Script.ResultOwnership.None */ + ); + }; + _initializeEntryAddedEventListener = new WeakSet(); + initializeEntryAddedEventListener_fn = function() { + __privateGet(this, _cdpTarget).cdpClient.on("Runtime.consoleAPICalled", (params) => { + var _a4; + const realm = __privateGet(this, _realmStorage).findRealm({ + cdpSessionId: __privateGet(this, _cdpTarget).cdpSessionId, + executionContextId: params.executionContextId + }); + if (realm === void 0) { + (_a4 = __privateGet(this, _logger)) == null ? void 0 : _a4.call(this, log_js_1.LogType.cdp, params); + return; + } + const argsPromise = Promise.all(params.args.map((arg) => __privateMethod(this, _heuristicSerializeArg, heuristicSerializeArg_fn).call(this, arg, realm))); + for (const browsingContext of realm.associatedBrowsingContexts) { + __privateGet(this, _eventManager).registerPromiseEvent(argsPromise.then((args) => ({ + kind: "success", + value: { + type: "event", + method: protocol_js_1.ChromiumBidi.Log.EventNames.LogEntryAdded, + params: { + level: getLogLevel(params.type), + source: realm.source, + text: (0, logHelper_js_1.getRemoteValuesText)(args, true), + timestamp: Math.round(params.timestamp), + stackTrace: getBidiStackTrace(params.stackTrace), + type: "console", + method: getLogMethod(params.type), + args + } + } + }), (error) => ({ + kind: "error", + error + })), browsingContext.id, protocol_js_1.ChromiumBidi.Log.EventNames.LogEntryAdded); + } + }); + __privateGet(this, _cdpTarget).cdpClient.on("Runtime.exceptionThrown", (params) => { + var _a4, _b; + const realm = __privateGet(this, _realmStorage).findRealm({ + cdpSessionId: __privateGet(this, _cdpTarget).cdpSessionId, + executionContextId: params.exceptionDetails.executionContextId + }); + if (realm === void 0) { + (_a4 = __privateGet(this, _logger)) == null ? void 0 : _a4.call(this, log_js_1.LogType.cdp, params); + return; + } + for (const browsingContext of realm.associatedBrowsingContexts) { + __privateGet(this, _eventManager).registerPromiseEvent(__privateMethod(_b = _a3, _getExceptionText, getExceptionText_fn).call(_b, params, realm).then((text) => ({ + kind: "success", + value: { + type: "event", + method: protocol_js_1.ChromiumBidi.Log.EventNames.LogEntryAdded, + params: { + level: "error", + source: realm.source, + text, + timestamp: Math.round(params.timestamp), + stackTrace: getBidiStackTrace(params.exceptionDetails.stackTrace), + type: "javascript" + } + } + }), (error) => ({ + kind: "error", + error + })), browsingContext.id, protocol_js_1.ChromiumBidi.Log.EventNames.LogEntryAdded); + } + }); + }; + _getExceptionText = new WeakSet(); + getExceptionText_fn = async function(params, realm) { + if (!params.exceptionDetails.exception) { + return params.exceptionDetails.text; + } + if (realm === void 0) { + return JSON.stringify(params.exceptionDetails.exception); + } + return await realm.stringifyObject(params.exceptionDetails.exception); + }; + /** + * Try the best to get the exception text. + */ + __privateAdd(LogManager, _getExceptionText); + exports.LogManager = LogManager; + _a3 = LogManager; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/cdp/CdpTarget.js +var require_CdpTarget = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/cdp/CdpTarget.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.CdpTarget = void 0; + var chromium_bidi_js_1 = require_chromium_bidi(); + var Deferred_js_1 = require_Deferred(); + var log_js_1 = require_log(); + var BrowsingContextImpl_js_1 = require_BrowsingContextImpl(); + var LogManager_js_1 = require_LogManager(); + var CdpTarget = class { + #id; + #cdpClient; + #browserCdpClient; + #realmStorage; + #eventManager; + #preloadScriptStorage; + #browsingContextStorage; + #networkStorage; + #unblocked = new Deferred_js_1.Deferred(); + #unhandledPromptBehavior; + #logger; + #deviceAccessEnabled = false; + #cacheDisableState = false; + #networkDomainEnabled = false; + #fetchDomainStages = { + request: false, + response: false, + auth: false + }; + static create(targetId, cdpClient, browserCdpClient, realmStorage, eventManager, preloadScriptStorage, browsingContextStorage, networkStorage, unhandledPromptBehavior, logger) { + const cdpTarget = new CdpTarget(targetId, cdpClient, browserCdpClient, eventManager, realmStorage, preloadScriptStorage, browsingContextStorage, networkStorage, unhandledPromptBehavior, logger); + LogManager_js_1.LogManager.create(cdpTarget, realmStorage, eventManager, logger); + cdpTarget.#setEventListeners(); + void cdpTarget.#unblock(); + return cdpTarget; + } + constructor(targetId, cdpClient, browserCdpClient, eventManager, realmStorage, preloadScriptStorage, browsingContextStorage, networkStorage, unhandledPromptBehavior, logger) { + this.#id = targetId; + this.#cdpClient = cdpClient; + this.#browserCdpClient = browserCdpClient; + this.#eventManager = eventManager; + this.#realmStorage = realmStorage; + this.#preloadScriptStorage = preloadScriptStorage; + this.#networkStorage = networkStorage; + this.#browsingContextStorage = browsingContextStorage; + this.#unhandledPromptBehavior = unhandledPromptBehavior; + this.#logger = logger; + } + /** Returns a deferred that resolves when the target is unblocked. */ + get unblocked() { + return this.#unblocked; + } + get id() { + return this.#id; + } + get cdpClient() { + return this.#cdpClient; + } + get browserCdpClient() { + return this.#browserCdpClient; + } + /** Needed for CDP escape path. */ + get cdpSessionId() { + return this.#cdpClient.sessionId; + } + /** + * Enables all the required CDP domains and unblocks the target. + */ + async #unblock() { + try { + await Promise.all([ + this.#cdpClient.sendCommand("Page.enable"), + // There can be some existing frames in the target, if reconnecting to an + // existing browser instance, e.g. via Puppeteer. Need to restore the browsing + // contexts for the frames to correctly handle further events, like + // `Runtime.executionContextCreated`. + // It's important to schedule this task together with enabling domains commands to + // prepare the tree before the events (e.g. Runtime.executionContextCreated) start + // coming. + // https://github.com/GoogleChromeLabs/chromium-bidi/issues/2282 + this.#cdpClient.sendCommand("Page.getFrameTree").then((frameTree) => this.#restoreFrameTreeState(frameTree.frameTree)), + this.#cdpClient.sendCommand("Runtime.enable"), + this.#cdpClient.sendCommand("Page.setLifecycleEventsEnabled", { + enabled: true + }), + this.toggleNetworkIfNeeded(), + this.#cdpClient.sendCommand("Target.setAutoAttach", { + autoAttach: true, + waitForDebuggerOnStart: true, + flatten: true + }), + this.#initAndEvaluatePreloadScripts(), + this.#cdpClient.sendCommand("Runtime.runIfWaitingForDebugger"), + this.toggleDeviceAccessIfNeeded() + ]); + } catch (error) { + this.#logger?.(log_js_1.LogType.debugError, "Failed to unblock target", error); + if (!this.#cdpClient.isCloseError(error)) { + this.#unblocked.resolve({ + kind: "error", + error + }); + return; + } + } + this.#unblocked.resolve({ + kind: "success", + value: void 0 + }); + } + #restoreFrameTreeState(frameTree) { + const frame = frameTree.frame; + const maybeContext = this.#browsingContextStorage.findContext(frame.id); + if (maybeContext !== void 0) { + if (maybeContext.parentId === null && frame.parentId !== null && frame.parentId !== void 0) { + maybeContext.parentId = frame.parentId; + } + } + if (maybeContext === void 0 && frame.parentId !== void 0) { + const parentBrowsingContext = this.#browsingContextStorage.getContext(frame.parentId); + BrowsingContextImpl_js_1.BrowsingContextImpl.create(frame.id, frame.parentId, parentBrowsingContext.userContext, parentBrowsingContext.cdpTarget, this.#eventManager, this.#browsingContextStorage, this.#realmStorage, frame.url, void 0, this.#unhandledPromptBehavior, this.#logger); + } + frameTree.childFrames?.map((frameTree2) => this.#restoreFrameTreeState(frameTree2)); + } + async toggleFetchIfNeeded() { + const stages = this.#networkStorage.getInterceptionStages(this.topLevelId); + if ( + // Only toggle interception when Network is enabled + !this.#networkDomainEnabled || this.#fetchDomainStages.request === stages.request && this.#fetchDomainStages.response === stages.response && this.#fetchDomainStages.auth === stages.auth + ) { + return; + } + const patterns = []; + this.#fetchDomainStages = stages; + if (stages.request || stages.auth) { + patterns.push({ + urlPattern: "*", + requestStage: "Request" + }); + } + if (stages.response) { + patterns.push({ + urlPattern: "*", + requestStage: "Response" + }); + } + if (patterns.length) { + await this.#cdpClient.sendCommand("Fetch.enable", { + patterns, + handleAuthRequests: stages.auth + }); + } else { + await this.#cdpClient.sendCommand("Fetch.disable"); + } + } + /** + * Toggles both Network and Fetch domains. + */ + async toggleNetworkIfNeeded() { + const enabled = this.isSubscribedTo(chromium_bidi_js_1.BiDiModule.Network); + if (enabled === this.#networkDomainEnabled) { + return; + } + this.#networkDomainEnabled = enabled; + try { + await Promise.all([ + this.#cdpClient.sendCommand(enabled ? "Network.enable" : "Network.disable").then(async () => await this.toggleSetCacheDisabled()), + this.toggleFetchIfNeeded() + ]); + } catch (err) { + this.#logger?.(log_js_1.LogType.debugError, err); + this.#networkDomainEnabled = !enabled; + if (!this.#isExpectedError(err)) { + throw err; + } + } + } + async toggleSetCacheDisabled(disable) { + const defaultCacheDisabled = this.#networkStorage.defaultCacheBehavior === "bypass"; + const cacheDisabled = disable ?? defaultCacheDisabled; + if (!this.#networkDomainEnabled || this.#cacheDisableState === cacheDisabled) { + return; + } + this.#cacheDisableState = cacheDisabled; + try { + await this.#cdpClient.sendCommand("Network.setCacheDisabled", { + cacheDisabled + }); + } catch (err) { + this.#logger?.(log_js_1.LogType.debugError, err); + this.#cacheDisableState = !cacheDisabled; + if (!this.#isExpectedError(err)) { + throw err; + } + } + } + async toggleDeviceAccessIfNeeded() { + const enabled = this.isSubscribedTo(chromium_bidi_js_1.BiDiModule.Bluetooth); + if (this.#deviceAccessEnabled === enabled) { + return; + } + this.#deviceAccessEnabled = enabled; + try { + await this.#cdpClient.sendCommand(enabled ? "DeviceAccess.enable" : "DeviceAccess.disable"); + } catch (err) { + this.#logger?.(log_js_1.LogType.debugError, err); + this.#deviceAccessEnabled = !enabled; + if (!this.#isExpectedError(err)) { + throw err; + } + } + } + /** + * Heuristic checking if the error is due to the session being closed. If so, ignore the + * error. + */ + #isExpectedError(err) { + const error = err; + return error.code === -32001 && error.message === "Session with given id not found."; + } + #setEventListeners() { + this.#cdpClient.on("*", (event, params) => { + if (typeof event !== "string") { + return; + } + this.#eventManager.registerEvent({ + type: "event", + method: `cdp.${event}`, + params: { + event, + params, + session: this.cdpSessionId + } + }, this.id); + }); + } + /** + * All the ProxyChannels from all the preload scripts of the given + * BrowsingContext. + */ + getChannels() { + return this.#preloadScriptStorage.find().flatMap((script) => script.channels); + } + /** Loads all top-level preload scripts. */ + async #initAndEvaluatePreloadScripts() { + await Promise.all(this.#preloadScriptStorage.find({ + // Needed for OOPIF + targetId: this.topLevelId, + global: true + }).map((script) => { + return script.initInTarget(this, true); + })); + } + get topLevelId() { + return this.#browsingContextStorage.findTopLevelContextId(this.id) ?? this.id; + } + isSubscribedTo(moduleOrEvent) { + return this.#eventManager.subscriptionManager.isSubscribedTo(moduleOrEvent, this.topLevelId); + } + }; + exports.CdpTarget = CdpTarget; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/cdp/CdpTargetManager.js +var require_CdpTargetManager = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/cdp/CdpTargetManager.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.CdpTargetManager = void 0; + var log_js_1 = require_log(); + var BrowsingContextImpl_js_1 = require_BrowsingContextImpl(); + var WorkerRealm_js_1 = require_WorkerRealm(); + var CdpTarget_js_1 = require_CdpTarget(); + var cdpToBidiTargetTypes = { + service_worker: "service-worker", + shared_worker: "shared-worker", + worker: "dedicated-worker" + }; + var CdpTargetManager = class { + #browserCdpClient; + #cdpConnection; + #targetKeysToBeIgnoredByAutoAttach = /* @__PURE__ */ new Set(); + #selfTargetId; + #eventManager; + #browsingContextStorage; + #networkStorage; + #bluetoothProcessor; + #preloadScriptStorage; + #realmStorage; + #defaultUserContextId; + #logger; + #unhandledPromptBehavior; + constructor(cdpConnection, browserCdpClient, selfTargetId, eventManager, browsingContextStorage, realmStorage, networkStorage, bluetoothProcessor, preloadScriptStorage, defaultUserContextId, unhandledPromptBehavior, logger) { + this.#cdpConnection = cdpConnection; + this.#browserCdpClient = browserCdpClient; + this.#targetKeysToBeIgnoredByAutoAttach.add(selfTargetId); + this.#selfTargetId = selfTargetId; + this.#eventManager = eventManager; + this.#browsingContextStorage = browsingContextStorage; + this.#preloadScriptStorage = preloadScriptStorage; + this.#networkStorage = networkStorage; + this.#bluetoothProcessor = bluetoothProcessor; + this.#realmStorage = realmStorage; + this.#defaultUserContextId = defaultUserContextId; + this.#unhandledPromptBehavior = unhandledPromptBehavior; + this.#logger = logger; + this.#setEventListeners(browserCdpClient); + } + /** + * This method is called for each CDP session, since this class is responsible + * for creating and destroying all targets and browsing contexts. + */ + #setEventListeners(cdpClient) { + cdpClient.on("Target.attachedToTarget", (params) => { + this.#handleAttachedToTargetEvent(params, cdpClient); + }); + cdpClient.on("Target.detachedFromTarget", this.#handleDetachedFromTargetEvent.bind(this)); + cdpClient.on("Target.targetInfoChanged", this.#handleTargetInfoChangedEvent.bind(this)); + cdpClient.on("Inspector.targetCrashed", () => { + this.#handleTargetCrashedEvent(cdpClient); + }); + cdpClient.on("Page.frameAttached", this.#handleFrameAttachedEvent.bind(this)); + cdpClient.on("Page.frameDetached", this.#handleFrameDetachedEvent.bind(this)); + cdpClient.on("Page.frameSubtreeWillBeDetached", this.#handleFrameSubtreeWillBeDetached.bind(this)); + } + #handleFrameAttachedEvent(params) { + const parentBrowsingContext = this.#browsingContextStorage.findContext(params.parentFrameId); + if (parentBrowsingContext !== void 0) { + BrowsingContextImpl_js_1.BrowsingContextImpl.create( + params.frameId, + params.parentFrameId, + parentBrowsingContext.userContext, + parentBrowsingContext.cdpTarget, + this.#eventManager, + this.#browsingContextStorage, + this.#realmStorage, + // At this point, we don't know the URL of the frame yet, so it will be updated + // later. + "about:blank", + void 0, + this.#unhandledPromptBehavior, + this.#logger + ); + } + } + #handleFrameDetachedEvent(params) { + if (params.reason === "swap") { + return; + } + this.#browsingContextStorage.findContext(params.frameId)?.dispose(true); + } + #handleFrameSubtreeWillBeDetached(params) { + this.#browsingContextStorage.findContext(params.frameId)?.dispose(true); + } + #handleAttachedToTargetEvent(params, parentSessionCdpClient) { + const { sessionId, targetInfo } = params; + const targetCdpClient = this.#cdpConnection.getCdpClient(sessionId); + const detach = async () => { + await targetCdpClient.sendCommand("Runtime.runIfWaitingForDebugger").then(() => parentSessionCdpClient.sendCommand("Target.detachFromTarget", params)).catch((error) => this.#logger?.(log_js_1.LogType.debugError, error)); + }; + if (this.#selfTargetId !== targetInfo.targetId) { + const targetKey = targetInfo.type === "service_worker" ? `${parentSessionCdpClient.sessionId}_${targetInfo.targetId}` : targetInfo.targetId; + if (this.#targetKeysToBeIgnoredByAutoAttach.has(targetKey)) { + return; + } + this.#targetKeysToBeIgnoredByAutoAttach.add(targetKey); + } + switch (targetInfo.type) { + case "page": + case "iframe": { + if (this.#selfTargetId === targetInfo.targetId) { + void detach(); + return; + } + const cdpTarget = this.#createCdpTarget(targetCdpClient, targetInfo); + const maybeContext = this.#browsingContextStorage.findContext(targetInfo.targetId); + if (maybeContext && targetInfo.type === "iframe") { + maybeContext.updateCdpTarget(cdpTarget); + } else { + const userContext = targetInfo.browserContextId && targetInfo.browserContextId !== this.#defaultUserContextId ? targetInfo.browserContextId : "default"; + BrowsingContextImpl_js_1.BrowsingContextImpl.create( + targetInfo.targetId, + null, + userContext, + cdpTarget, + this.#eventManager, + this.#browsingContextStorage, + this.#realmStorage, + // Hack: when a new target created, CDP emits targetInfoChanged with an empty + // url, and navigates it to about:blank later. When the event is emitted for + // an existing target (reconnect), the url is already known, and navigation + // events will not be emitted anymore. Replacing empty url with `about:blank` + // allows to handle both cases in the same way. + // "7.3.2.1 Creating browsing contexts". + // https://html.spec.whatwg.org/multipage/document-sequences.html#creating-browsing-contexts + // TODO: check who to deal with non-null creator and its `creatorOrigin`. + targetInfo.url === "" ? "about:blank" : targetInfo.url, + targetInfo.openerFrameId ?? targetInfo.openerId, + this.#unhandledPromptBehavior, + this.#logger + ); + } + return; + } + case "service_worker": + case "worker": { + const realm = this.#realmStorage.findRealm({ + cdpSessionId: parentSessionCdpClient.sessionId + }); + if (!realm) { + void detach(); + return; + } + const cdpTarget = this.#createCdpTarget(targetCdpClient, targetInfo); + this.#handleWorkerTarget(cdpToBidiTargetTypes[targetInfo.type], cdpTarget, realm); + return; + } + case "shared_worker": { + const cdpTarget = this.#createCdpTarget(targetCdpClient, targetInfo); + this.#handleWorkerTarget(cdpToBidiTargetTypes[targetInfo.type], cdpTarget); + return; + } + } + void detach(); + } + #createCdpTarget(targetCdpClient, targetInfo) { + this.#setEventListeners(targetCdpClient); + const target = CdpTarget_js_1.CdpTarget.create(targetInfo.targetId, targetCdpClient, this.#browserCdpClient, this.#realmStorage, this.#eventManager, this.#preloadScriptStorage, this.#browsingContextStorage, this.#networkStorage, this.#unhandledPromptBehavior, this.#logger); + this.#networkStorage.onCdpTargetCreated(target); + this.#bluetoothProcessor.onCdpTargetCreated(target); + return target; + } + #workers = /* @__PURE__ */ new Map(); + #handleWorkerTarget(realmType, cdpTarget, ownerRealm) { + cdpTarget.cdpClient.on("Runtime.executionContextCreated", (params) => { + const { uniqueId, id, origin } = params.context; + const workerRealm = new WorkerRealm_js_1.WorkerRealm(cdpTarget.cdpClient, this.#eventManager, id, this.#logger, (0, BrowsingContextImpl_js_1.serializeOrigin)(origin), ownerRealm ? [ownerRealm] : [], uniqueId, this.#realmStorage, realmType); + this.#workers.set(cdpTarget.cdpSessionId, workerRealm); + }); + } + #handleDetachedFromTargetEvent({ sessionId, targetId }) { + if (targetId) { + this.#preloadScriptStorage.find({ targetId }).map((preloadScript) => { + preloadScript.dispose(targetId); + }); + } + const context = this.#browsingContextStorage.findContextBySession(sessionId); + if (context) { + context.dispose(true); + return; + } + const worker = this.#workers.get(sessionId); + if (worker) { + this.#realmStorage.deleteRealms({ + cdpSessionId: worker.cdpClient.sessionId + }); + } + } + #handleTargetInfoChangedEvent(params) { + const context = this.#browsingContextStorage.findContext(params.targetInfo.targetId); + if (context) { + context.onTargetInfoChanged(params); + } + } + #handleTargetCrashedEvent(cdpClient) { + const realms = this.#realmStorage.findRealms({ + cdpSessionId: cdpClient.sessionId + }); + for (const realm of realms) { + realm.dispose(); + } + } + }; + exports.CdpTargetManager = CdpTargetManager; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/context/BrowsingContextStorage.js +var require_BrowsingContextStorage = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/context/BrowsingContextStorage.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BrowsingContextStorage = void 0; + var protocol_js_1 = require_protocol(); + var BrowsingContextStorage = class { + /** Map from context ID to context implementation. */ + #contexts = /* @__PURE__ */ new Map(); + /** Gets all top-level contexts, i.e. those with no parent. */ + getTopLevelContexts() { + return this.getAllContexts().filter((context) => context.isTopLevelContext()); + } + /** Gets all contexts. */ + getAllContexts() { + return Array.from(this.#contexts.values()); + } + /** Deletes the context with the given ID. */ + deleteContextById(id) { + this.#contexts.delete(id); + } + /** Deletes the given context. */ + deleteContext(context) { + this.#contexts.delete(context.id); + } + /** Tracks the given context. */ + addContext(context) { + this.#contexts.set(context.id, context); + } + /** Returns true whether there is an existing context with the given ID. */ + hasContext(id) { + return this.#contexts.has(id); + } + /** Gets the context with the given ID, if any. */ + findContext(id) { + return this.#contexts.get(id); + } + /** Returns the top-level context ID of the given context, if any. */ + findTopLevelContextId(id) { + if (id === null) { + return null; + } + const maybeContext = this.findContext(id); + const parentId = maybeContext?.parentId ?? null; + if (parentId === null) { + return id; + } + return this.findTopLevelContextId(parentId); + } + findContextBySession(sessionId) { + for (const context of this.#contexts.values()) { + if (context.cdpTarget.cdpSessionId === sessionId) { + return context; + } + } + return; + } + /** Gets the context with the given ID, if any, otherwise throws. */ + getContext(id) { + const result = this.findContext(id); + if (result === void 0) { + throw new protocol_js_1.NoSuchFrameException(`Context ${id} not found`); + } + return result; + } + verifyTopLevelContextsList(contexts) { + const foundContexts = /* @__PURE__ */ new Set(); + if (!contexts) { + return foundContexts; + } + for (const contextId of contexts) { + const context = this.getContext(contextId); + if (context.isTopLevelContext()) { + foundContexts.add(context); + } else { + throw new protocol_js_1.InvalidArgumentException(`Non top-level context '${contextId}' given.`); + } + } + return foundContexts; + } + }; + exports.BrowsingContextStorage = BrowsingContextStorage; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/network/NetworkRequest.js +var require_NetworkRequest = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/network/NetworkRequest.js"(exports) { + "use strict"; + init_cjs_shim(); + var _a3; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.NetworkRequest = void 0; + var protocol_js_1 = require_protocol(); + var assert_js_1 = require_assert(); + var Deferred_js_1 = require_Deferred(); + var log_js_1 = require_log(); + var NetworkUtils_js_1 = require_NetworkUtils(); + var REALM_REGEX = /(?<=realm=").*(?=")/; + var _id, _fetchId, _interceptPhase, _servedFromCache, _redirectCount, _request, _requestOverrides, _responseOverrides, _response, _eventManager, _networkStorage, _cdpTarget, _logger, _emittedEvents, _isDataUrl, isDataUrl_fn, _method, method_get, _navigationId, navigationId_get, _cookies, cookies_get, _bodySize, bodySize_get, _context, context_get, _statusCode, statusCode_get, _requestHeaders, requestHeaders_get, _authChallenges, authChallenges_get, _timings, timings_get, _phaseChanged, phaseChanged_fn, _interceptsInPhase, interceptsInPhase_fn, _isBlockedInPhase, isBlockedInPhase_fn, _emitEventsIfReady, emitEventsIfReady_fn, _continueRequest, continueRequest_fn, _continueResponse, continueResponse_fn, _continueWithAuth, continueWithAuth_fn, _emitEvent, emitEvent_fn, _getBaseEventParams, getBaseEventParams_fn, _getResponseEventParams, getResponseEventParams_fn, _getRequestData, getRequestData_fn, _getBeforeRequestEvent, getBeforeRequestEvent_fn, _getResponseStartedEvent, getResponseStartedEvent_fn, _getResponseReceivedEvent, getResponseReceivedEvent_fn, _isIgnoredEvent, isIgnoredEvent_fn, _getOverrideHeader, getOverrideHeader_fn, _getInitiatorType, getInitiatorType_fn; + var NetworkRequest = class { + constructor(id, eventManager, networkStorage, cdpTarget, redirectCount = 0, logger) { + __privateAdd(this, _isDataUrl); + __privateAdd(this, _method); + __privateAdd(this, _navigationId); + __privateAdd(this, _cookies); + __privateAdd(this, _bodySize); + __privateAdd(this, _context); + /** Returns the HTTP status code associated with this request if any. */ + __privateAdd(this, _statusCode); + __privateAdd(this, _requestHeaders); + __privateAdd(this, _authChallenges); + __privateAdd(this, _timings); + __privateAdd(this, _phaseChanged); + __privateAdd(this, _interceptsInPhase); + __privateAdd(this, _isBlockedInPhase); + __privateAdd(this, _emitEventsIfReady); + __privateAdd(this, _continueRequest); + __privateAdd(this, _continueResponse); + __privateAdd(this, _continueWithAuth); + __privateAdd(this, _emitEvent); + __privateAdd(this, _getBaseEventParams); + __privateAdd(this, _getResponseEventParams); + __privateAdd(this, _getRequestData); + __privateAdd(this, _getBeforeRequestEvent); + __privateAdd(this, _getResponseStartedEvent); + __privateAdd(this, _getResponseReceivedEvent); + __privateAdd(this, _isIgnoredEvent); + __privateAdd(this, _getOverrideHeader); + /** + * Each network request has an associated request id, which is a string + * uniquely identifying that request. + * + * The identifier for a request resulting from a redirect matches that of the + * request that initiated it. + */ + __privateAdd(this, _id, void 0); + __privateAdd(this, _fetchId, void 0); + /** + * Indicates the network intercept phase, if the request is currently blocked. + * Undefined necessarily implies that the request is not blocked. + */ + __privateAdd(this, _interceptPhase, void 0); + __privateAdd(this, _servedFromCache, false); + __privateAdd(this, _redirectCount, void 0); + __privateAdd(this, _request, {}); + __privateAdd(this, _requestOverrides, void 0); + __privateAdd(this, _responseOverrides, void 0); + __privateAdd(this, _response, {}); + __privateAdd(this, _eventManager, void 0); + __privateAdd(this, _networkStorage, void 0); + __privateAdd(this, _cdpTarget, void 0); + __privateAdd(this, _logger, void 0); + __privateAdd(this, _emittedEvents, { + [protocol_js_1.ChromiumBidi.Network.EventNames.AuthRequired]: false, + [protocol_js_1.ChromiumBidi.Network.EventNames.BeforeRequestSent]: false, + [protocol_js_1.ChromiumBidi.Network.EventNames.FetchError]: false, + [protocol_js_1.ChromiumBidi.Network.EventNames.ResponseCompleted]: false, + [protocol_js_1.ChromiumBidi.Network.EventNames.ResponseStarted]: false + }); + __publicField(this, "waitNextPhase", new Deferred_js_1.Deferred()); + __privateSet(this, _id, id); + __privateSet(this, _eventManager, eventManager); + __privateSet(this, _networkStorage, networkStorage); + __privateSet(this, _cdpTarget, cdpTarget); + __privateSet(this, _redirectCount, redirectCount); + __privateSet(this, _logger, logger); + } + get id() { + return __privateGet(this, _id); + } + get fetchId() { + return __privateGet(this, _fetchId); + } + /** + * When blocked returns the phase for it + */ + get interceptPhase() { + return __privateGet(this, _interceptPhase); + } + get url() { + const fragment = __privateGet(this, _request).info?.request.urlFragment ?? __privateGet(this, _request).paused?.request.urlFragment ?? ""; + const url = __privateGet(this, _response).info?.url ?? __privateGet(this, _response).paused?.request.url ?? __privateGet(this, _requestOverrides)?.url ?? __privateGet(this, _request).auth?.request.url ?? __privateGet(this, _request).info?.request.url ?? __privateGet(this, _request).paused?.request.url ?? _a3.unknownParameter; + return `${url}${fragment}`; + } + get redirectCount() { + return __privateGet(this, _redirectCount); + } + get cdpTarget() { + return __privateGet(this, _cdpTarget); + } + get cdpClient() { + return __privateGet(this, _cdpTarget).cdpClient; + } + isRedirecting() { + return Boolean(__privateGet(this, _request).info); + } + handleRedirect(event) { + __privateGet(this, _response).hasExtraInfo = false; + __privateGet(this, _response).info = event.redirectResponse; + __privateMethod(this, _emitEventsIfReady, emitEventsIfReady_fn).call(this, { + wasRedirected: true + }); + } + onRequestWillBeSentEvent(event) { + __privateGet(this, _request).info = event; + __privateMethod(this, _emitEventsIfReady, emitEventsIfReady_fn).call(this); + } + onRequestWillBeSentExtraInfoEvent(event) { + __privateGet(this, _request).extraInfo = event; + __privateMethod(this, _emitEventsIfReady, emitEventsIfReady_fn).call(this); + } + onResponseReceivedExtraInfoEvent(event) { + if (event.statusCode >= 300 && event.statusCode <= 399 && __privateGet(this, _request).info && event.headers["location"] === __privateGet(this, _request).info.request.url) { + return; + } + __privateGet(this, _response).extraInfo = event; + __privateMethod(this, _emitEventsIfReady, emitEventsIfReady_fn).call(this); + } + onResponseReceivedEvent(event) { + __privateGet(this, _response).hasExtraInfo = event.hasExtraInfo; + __privateGet(this, _response).info = event.response; + __privateMethod(this, _emitEventsIfReady, emitEventsIfReady_fn).call(this); + } + onServedFromCache() { + __privateSet(this, _servedFromCache, true); + __privateMethod(this, _emitEventsIfReady, emitEventsIfReady_fn).call(this); + } + onLoadingFailedEvent(event) { + __privateMethod(this, _emitEventsIfReady, emitEventsIfReady_fn).call(this, { + hasFailed: true + }); + __privateMethod(this, _emitEvent, emitEvent_fn).call(this, () => { + return { + method: protocol_js_1.ChromiumBidi.Network.EventNames.FetchError, + params: { + ...__privateMethod(this, _getBaseEventParams, getBaseEventParams_fn).call(this), + errorText: event.errorText + } + }; + }); + } + /** @see https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-failRequest */ + async failRequest(errorReason) { + (0, assert_js_1.assert)(__privateGet(this, _fetchId), "Network Interception not set-up."); + await this.cdpClient.sendCommand("Fetch.failRequest", { + requestId: __privateGet(this, _fetchId), + errorReason + }); + __privateSet(this, _interceptPhase, void 0); + } + onRequestPaused(event) { + __privateSet(this, _fetchId, event.requestId); + if (event.responseStatusCode || event.responseErrorReason) { + __privateGet(this, _response).paused = event; + if (__privateMethod(this, _isBlockedInPhase, isBlockedInPhase_fn).call(this, "responseStarted") && // CDP may emit multiple events for a single request + !__privateGet(this, _emittedEvents)[protocol_js_1.ChromiumBidi.Network.EventNames.ResponseStarted] && // Continue all response that have not enabled Network domain + __privateGet(this, _fetchId) !== this.id) { + __privateSet(this, _interceptPhase, "responseStarted"); + } else { + void __privateMethod(this, _continueResponse, continueResponse_fn).call(this); + } + } else { + __privateGet(this, _request).paused = event; + if (__privateMethod(this, _isBlockedInPhase, isBlockedInPhase_fn).call(this, "beforeRequestSent") && // CDP may emit multiple events for a single request + !__privateGet(this, _emittedEvents)[protocol_js_1.ChromiumBidi.Network.EventNames.BeforeRequestSent] && // Continue all requests that have not enabled Network domain + __privateGet(this, _fetchId) !== this.id) { + __privateSet(this, _interceptPhase, "beforeRequestSent"); + } else { + void __privateMethod(this, _continueRequest, continueRequest_fn).call(this); + } + } + __privateMethod(this, _emitEventsIfReady, emitEventsIfReady_fn).call(this); + } + onAuthRequired(event) { + __privateSet(this, _fetchId, event.requestId); + __privateGet(this, _request).auth = event; + if (__privateMethod(this, _isBlockedInPhase, isBlockedInPhase_fn).call(this, "authRequired") && // Continue all auth requests that have not enabled Network domain + __privateGet(this, _fetchId) !== this.id) { + __privateSet(this, _interceptPhase, "authRequired"); + } else { + void __privateMethod(this, _continueWithAuth, continueWithAuth_fn).call(this, { + response: "Default" + }); + } + __privateMethod(this, _emitEvent, emitEvent_fn).call(this, () => { + return { + method: protocol_js_1.ChromiumBidi.Network.EventNames.AuthRequired, + params: { + ...__privateMethod(this, _getBaseEventParams, getBaseEventParams_fn).call(this, "authRequired"), + response: __privateMethod(this, _getResponseEventParams, getResponseEventParams_fn).call(this) + } + }; + }); + } + /** @see https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-continueRequest */ + async continueRequest(overrides = {}) { + const overrideHeaders = __privateMethod(this, _getOverrideHeader, getOverrideHeader_fn).call(this, overrides.headers, overrides.cookies); + const headers = (0, NetworkUtils_js_1.cdpFetchHeadersFromBidiNetworkHeaders)(overrideHeaders); + const postData = getCdpBodyFromBiDiBytesValue(overrides.body); + await __privateMethod(this, _continueRequest, continueRequest_fn).call(this, { + url: overrides.url, + method: overrides.method, + headers, + postData + }); + __privateSet(this, _requestOverrides, { + url: overrides.url, + method: overrides.method, + headers: overrides.headers, + cookies: overrides.cookies, + bodySize: getSizeFromBiDiBytesValue(overrides.body) + }); + } + /** @see https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-continueResponse */ + async continueResponse(overrides = {}) { + if (this.interceptPhase === "authRequired") { + if (overrides.credentials) { + await Promise.all([ + this.waitNextPhase, + await __privateMethod(this, _continueWithAuth, continueWithAuth_fn).call(this, { + response: "ProvideCredentials", + username: overrides.credentials.username, + password: overrides.credentials.password + }) + ]); + } else { + return await __privateMethod(this, _continueWithAuth, continueWithAuth_fn).call(this, { + response: "ProvideCredentials" + }); + } + } + if (__privateGet(this, _interceptPhase) === "responseStarted") { + const overrideHeaders = __privateMethod(this, _getOverrideHeader, getOverrideHeader_fn).call(this, overrides.headers, overrides.cookies); + const responseHeaders = (0, NetworkUtils_js_1.cdpFetchHeadersFromBidiNetworkHeaders)(overrideHeaders); + await __privateMethod(this, _continueResponse, continueResponse_fn).call(this, { + responseCode: overrides.statusCode ?? __privateGet(this, _response).paused?.responseStatusCode, + responsePhrase: overrides.reasonPhrase ?? __privateGet(this, _response).paused?.responseStatusText, + responseHeaders: responseHeaders ?? __privateGet(this, _response).paused?.responseHeaders + }); + __privateSet(this, _responseOverrides, { + statusCode: overrides.statusCode, + headers: overrideHeaders + }); + } + } + /** @see https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-continueWithAuth */ + async continueWithAuth(authChallenge) { + let username; + let password; + if (authChallenge.action === "provideCredentials") { + const { credentials } = authChallenge; + username = credentials.username; + password = credentials.password; + } + const response = (0, NetworkUtils_js_1.cdpAuthChallengeResponseFromBidiAuthContinueWithAuthAction)(authChallenge.action); + await __privateMethod(this, _continueWithAuth, continueWithAuth_fn).call(this, { + response, + username, + password + }); + } + /** @see https://chromedevtools.github.io/devtools-protocol/tot/Fetch/#method-provideResponse */ + async provideResponse(overrides) { + (0, assert_js_1.assert)(__privateGet(this, _fetchId), "Network Interception not set-up."); + if (this.interceptPhase === "authRequired") { + return await __privateMethod(this, _continueWithAuth, continueWithAuth_fn).call(this, { + response: "ProvideCredentials" + }); + } + if (!overrides.body && !overrides.headers) { + return await __privateMethod(this, _continueRequest, continueRequest_fn).call(this); + } + const overrideHeaders = __privateMethod(this, _getOverrideHeader, getOverrideHeader_fn).call(this, overrides.headers, overrides.cookies); + const responseHeaders = (0, NetworkUtils_js_1.cdpFetchHeadersFromBidiNetworkHeaders)(overrideHeaders); + const responseCode = overrides.statusCode ?? __privateGet(this, _statusCode, statusCode_get) ?? 200; + await this.cdpClient.sendCommand("Fetch.fulfillRequest", { + requestId: __privateGet(this, _fetchId), + responseCode, + responsePhrase: overrides.reasonPhrase, + responseHeaders, + body: getCdpBodyFromBiDiBytesValue(overrides.body) + }); + __privateSet(this, _interceptPhase, void 0); + } + }; + _id = new WeakMap(); + _fetchId = new WeakMap(); + _interceptPhase = new WeakMap(); + _servedFromCache = new WeakMap(); + _redirectCount = new WeakMap(); + _request = new WeakMap(); + _requestOverrides = new WeakMap(); + _responseOverrides = new WeakMap(); + _response = new WeakMap(); + _eventManager = new WeakMap(); + _networkStorage = new WeakMap(); + _cdpTarget = new WeakMap(); + _logger = new WeakMap(); + _emittedEvents = new WeakMap(); + _isDataUrl = new WeakSet(); + isDataUrl_fn = function() { + return this.url.startsWith("data:"); + }; + _method = new WeakSet(); + method_get = function() { + return __privateGet(this, _requestOverrides)?.method ?? __privateGet(this, _request).info?.request.method ?? __privateGet(this, _request).paused?.request.method ?? __privateGet(this, _request).auth?.request.method ?? __privateGet(this, _response).paused?.request.method; + }; + _navigationId = new WeakSet(); + navigationId_get = function() { + if (!__privateGet(this, _request).info || !__privateGet(this, _request).info.loaderId || // When we navigate all CDP network events have `loaderId` + // CDP's `loaderId` and `requestId` match when + // that request triggered the loading + __privateGet(this, _request).info.loaderId !== __privateGet(this, _request).info.requestId) { + return null; + } + return __privateGet(this, _networkStorage).getNavigationId(__privateGet(this, _context, context_get) ?? void 0); + }; + _cookies = new WeakSet(); + cookies_get = function() { + let cookies = []; + if (__privateGet(this, _request).extraInfo) { + cookies = __privateGet(this, _request).extraInfo.associatedCookies.filter(({ blockedReasons }) => { + return !Array.isArray(blockedReasons) || blockedReasons.length === 0; + }).map(({ cookie }) => (0, NetworkUtils_js_1.cdpToBiDiCookie)(cookie)); + } + return cookies; + }; + _bodySize = new WeakSet(); + bodySize_get = function() { + let bodySize = 0; + if (typeof __privateGet(this, _requestOverrides)?.bodySize === "number") { + bodySize = __privateGet(this, _requestOverrides).bodySize; + } else { + bodySize = (0, NetworkUtils_js_1.bidiBodySizeFromCdpPostDataEntries)(__privateGet(this, _request).info?.request.postDataEntries ?? []); + } + return bodySize; + }; + _context = new WeakSet(); + context_get = function() { + return __privateGet(this, _response).paused?.frameId ?? __privateGet(this, _request).info?.frameId ?? __privateGet(this, _request).paused?.frameId ?? __privateGet(this, _request).auth?.frameId ?? null; + }; + _statusCode = new WeakSet(); + statusCode_get = function() { + return __privateGet(this, _responseOverrides)?.statusCode ?? __privateGet(this, _response).paused?.responseStatusCode ?? __privateGet(this, _response).extraInfo?.statusCode ?? __privateGet(this, _response).info?.status; + }; + _requestHeaders = new WeakSet(); + requestHeaders_get = function() { + let headers = []; + if (__privateGet(this, _requestOverrides)?.headers) { + headers = __privateGet(this, _requestOverrides).headers; + } else { + headers = [ + ...(0, NetworkUtils_js_1.bidiNetworkHeadersFromCdpNetworkHeaders)(__privateGet(this, _request).info?.request.headers), + ...(0, NetworkUtils_js_1.bidiNetworkHeadersFromCdpNetworkHeaders)(__privateGet(this, _request).extraInfo?.headers) + ]; + } + return headers; + }; + _authChallenges = new WeakSet(); + authChallenges_get = function() { + if (!__privateGet(this, _response).info) { + return; + } + if (!(__privateGet(this, _statusCode, statusCode_get) === 401 || __privateGet(this, _statusCode, statusCode_get) === 407)) { + return void 0; + } + const headerName = __privateGet(this, _statusCode, statusCode_get) === 401 ? "WWW-Authenticate" : "Proxy-Authenticate"; + const authChallenges = []; + for (const [header, value] of Object.entries(__privateGet(this, _response).info.headers)) { + if (header.localeCompare(headerName, void 0, { sensitivity: "base" }) === 0) { + authChallenges.push({ + scheme: value.split(" ").at(0) ?? "", + realm: value.match(REALM_REGEX)?.at(0) ?? "" + }); + } + } + return authChallenges; + }; + _timings = new WeakSet(); + timings_get = function() { + return { + // TODO: Verify this is correct + timeOrigin: (0, NetworkUtils_js_1.getTiming)(__privateGet(this, _response).info?.timing?.requestTime), + requestTime: (0, NetworkUtils_js_1.getTiming)(__privateGet(this, _response).info?.timing?.requestTime), + redirectStart: 0, + redirectEnd: 0, + // TODO: Verify this is correct + // https://source.chromium.org/chromium/chromium/src/+/main:net/base/load_timing_info.h;l=145 + fetchStart: (0, NetworkUtils_js_1.getTiming)(__privateGet(this, _response).info?.timing?.requestTime), + dnsStart: (0, NetworkUtils_js_1.getTiming)(__privateGet(this, _response).info?.timing?.dnsStart), + dnsEnd: (0, NetworkUtils_js_1.getTiming)(__privateGet(this, _response).info?.timing?.dnsEnd), + connectStart: (0, NetworkUtils_js_1.getTiming)(__privateGet(this, _response).info?.timing?.connectStart), + connectEnd: (0, NetworkUtils_js_1.getTiming)(__privateGet(this, _response).info?.timing?.connectEnd), + tlsStart: (0, NetworkUtils_js_1.getTiming)(__privateGet(this, _response).info?.timing?.sslStart), + requestStart: (0, NetworkUtils_js_1.getTiming)(__privateGet(this, _response).info?.timing?.sendStart), + // https://source.chromium.org/chromium/chromium/src/+/main:net/base/load_timing_info.h;l=196 + responseStart: (0, NetworkUtils_js_1.getTiming)(__privateGet(this, _response).info?.timing?.receiveHeadersStart), + responseEnd: (0, NetworkUtils_js_1.getTiming)(__privateGet(this, _response).info?.timing?.receiveHeadersEnd) + }; + }; + _phaseChanged = new WeakSet(); + phaseChanged_fn = function() { + this.waitNextPhase.resolve(); + this.waitNextPhase = new Deferred_js_1.Deferred(); + }; + _interceptsInPhase = new WeakSet(); + interceptsInPhase_fn = function(phase) { + if (!__privateGet(this, _cdpTarget).isSubscribedTo(`network.${phase}`)) { + return /* @__PURE__ */ new Set(); + } + return __privateGet(this, _networkStorage).getInterceptsForPhase(this, phase); + }; + _isBlockedInPhase = new WeakSet(); + isBlockedInPhase_fn = function(phase) { + return __privateMethod(this, _interceptsInPhase, interceptsInPhase_fn).call(this, phase).size > 0; + }; + _emitEventsIfReady = new WeakSet(); + emitEventsIfReady_fn = function(options = {}) { + const requestExtraInfoCompleted = ( + // Flush redirects + options.wasRedirected || options.hasFailed || __privateMethod(this, _isDataUrl, isDataUrl_fn).call(this) || Boolean(__privateGet(this, _request).extraInfo) || // Requests from cache don't have extra info + __privateGet(this, _servedFromCache) || // Sometimes there is no extra info and the response + // is the only place we can find out + Boolean(__privateGet(this, _response).info && !__privateGet(this, _response).hasExtraInfo) + ); + const noInterceptionExpected = ( + // We can't intercept data urls from CDP + __privateMethod(this, _isDataUrl, isDataUrl_fn).call(this) || // Cached requests never hit the network + __privateGet(this, _servedFromCache) + ); + const requestInterceptionExpected = !noInterceptionExpected && __privateMethod(this, _isBlockedInPhase, isBlockedInPhase_fn).call(this, "beforeRequestSent"); + const requestInterceptionCompleted = !requestInterceptionExpected || requestInterceptionExpected && Boolean(__privateGet(this, _request).paused); + if (Boolean(__privateGet(this, _request).info) && (requestInterceptionExpected ? requestInterceptionCompleted : requestExtraInfoCompleted)) { + __privateMethod(this, _emitEvent, emitEvent_fn).call(this, __privateMethod(this, _getBeforeRequestEvent, getBeforeRequestEvent_fn).bind(this)); + } + const responseExtraInfoCompleted = Boolean(__privateGet(this, _response).extraInfo) || // Response from cache don't have extra info + __privateGet(this, _servedFromCache) || // Don't expect extra info if the flag is false + Boolean(__privateGet(this, _response).info && !__privateGet(this, _response).hasExtraInfo); + const responseInterceptionExpected = !noInterceptionExpected && __privateMethod(this, _isBlockedInPhase, isBlockedInPhase_fn).call(this, "responseStarted"); + if (__privateGet(this, _response).info || responseInterceptionExpected && Boolean(__privateGet(this, _response).paused)) { + __privateMethod(this, _emitEvent, emitEvent_fn).call(this, __privateMethod(this, _getResponseStartedEvent, getResponseStartedEvent_fn).bind(this)); + } + const responseInterceptionCompleted = !responseInterceptionExpected || responseInterceptionExpected && Boolean(__privateGet(this, _response).paused); + if (Boolean(__privateGet(this, _response).info) && responseExtraInfoCompleted && responseInterceptionCompleted) { + __privateMethod(this, _emitEvent, emitEvent_fn).call(this, __privateMethod(this, _getResponseReceivedEvent, getResponseReceivedEvent_fn).bind(this)); + __privateGet(this, _networkStorage).deleteRequest(this.id); + } + }; + _continueRequest = new WeakSet(); + continueRequest_fn = async function(overrides = {}) { + (0, assert_js_1.assert)(__privateGet(this, _fetchId), "Network Interception not set-up."); + await this.cdpClient.sendCommand("Fetch.continueRequest", { + requestId: __privateGet(this, _fetchId), + url: overrides.url, + method: overrides.method, + headers: overrides.headers, + postData: overrides.postData + }); + __privateSet(this, _interceptPhase, void 0); + }; + _continueResponse = new WeakSet(); + continueResponse_fn = async function({ responseCode, responsePhrase, responseHeaders } = {}) { + (0, assert_js_1.assert)(__privateGet(this, _fetchId), "Network Interception not set-up."); + await this.cdpClient.sendCommand("Fetch.continueResponse", { + requestId: __privateGet(this, _fetchId), + responseCode, + responsePhrase, + responseHeaders + }); + __privateSet(this, _interceptPhase, void 0); + }; + _continueWithAuth = new WeakSet(); + continueWithAuth_fn = async function(authChallengeResponse) { + (0, assert_js_1.assert)(__privateGet(this, _fetchId), "Network Interception not set-up."); + await this.cdpClient.sendCommand("Fetch.continueWithAuth", { + requestId: __privateGet(this, _fetchId), + authChallengeResponse + }); + __privateSet(this, _interceptPhase, void 0); + }; + _emitEvent = new WeakSet(); + emitEvent_fn = function(getEvent) { + var _a4; + let event; + try { + event = getEvent(); + } catch (error) { + (_a4 = __privateGet(this, _logger)) == null ? void 0 : _a4.call(this, log_js_1.LogType.debugError, error); + return; + } + if (__privateMethod(this, _isIgnoredEvent, isIgnoredEvent_fn).call(this) || __privateGet(this, _emittedEvents)[event.method] && // Special case this event can be emitted multiple times + event.method !== protocol_js_1.ChromiumBidi.Network.EventNames.AuthRequired) { + return; + } + __privateMethod(this, _phaseChanged, phaseChanged_fn).call(this); + __privateGet(this, _emittedEvents)[event.method] = true; + __privateGet(this, _eventManager).registerEvent(Object.assign(event, { + type: "event" + }), __privateGet(this, _context, context_get)); + }; + _getBaseEventParams = new WeakSet(); + getBaseEventParams_fn = function(phase) { + const interceptProps = { + isBlocked: false + }; + if (phase) { + const blockedBy = __privateMethod(this, _interceptsInPhase, interceptsInPhase_fn).call(this, phase); + interceptProps.isBlocked = blockedBy.size > 0; + if (interceptProps.isBlocked) { + interceptProps.intercepts = [...blockedBy]; + } + } + return { + context: __privateGet(this, _context, context_get), + navigation: __privateGet(this, _navigationId, navigationId_get), + redirectCount: __privateGet(this, _redirectCount), + request: __privateMethod(this, _getRequestData, getRequestData_fn).call(this), + // Timestamp should be in milliseconds, while CDP provides it in seconds. + timestamp: Math.round((0, NetworkUtils_js_1.getTiming)(__privateGet(this, _request).info?.wallTime) * 1e3), + // Contains isBlocked and intercepts + ...interceptProps + }; + }; + _getResponseEventParams = new WeakSet(); + getResponseEventParams_fn = function() { + if (__privateGet(this, _response).info?.fromDiskCache) { + __privateGet(this, _response).extraInfo = void 0; + } + const headers = [ + ...(0, NetworkUtils_js_1.bidiNetworkHeadersFromCdpNetworkHeaders)(__privateGet(this, _response).info?.headers), + ...(0, NetworkUtils_js_1.bidiNetworkHeadersFromCdpNetworkHeaders)(__privateGet(this, _response).extraInfo?.headers) + // TODO: Verify how to dedupe these + // ...bidiNetworkHeadersFromCdpNetworkHeadersEntries( + // this.#response.paused?.responseHeaders + // ), + ]; + const authChallenges = __privateGet(this, _authChallenges, authChallenges_get); + return { + url: this.url, + protocol: __privateGet(this, _response).info?.protocol ?? "", + status: __privateGet(this, _statusCode, statusCode_get) ?? -1, + // TODO: Throw an exception or use some other status code? + statusText: __privateGet(this, _response).info?.statusText || __privateGet(this, _response).paused?.responseStatusText || "", + fromCache: __privateGet(this, _response).info?.fromDiskCache || __privateGet(this, _response).info?.fromPrefetchCache || __privateGet(this, _servedFromCache), + headers: __privateGet(this, _responseOverrides)?.headers ?? headers, + mimeType: __privateGet(this, _response).info?.mimeType || "", + bytesReceived: __privateGet(this, _response).info?.encodedDataLength || 0, + headersSize: (0, NetworkUtils_js_1.computeHeadersSize)(headers), + // TODO: consider removing from spec. + bodySize: 0, + content: { + // TODO: consider removing from spec. + size: 0 + }, + ...authChallenges ? { authChallenges } : {}, + // @ts-expect-error this is a CDP-specific extension. + "goog:securityDetails": __privateGet(this, _response).info?.securityDetails + }; + }; + _getRequestData = new WeakSet(); + getRequestData_fn = function() { + const headers = __privateGet(this, _requestHeaders, requestHeaders_get); + return { + request: __privateGet(this, _id), + url: this.url, + method: __privateGet(this, _method, method_get) ?? _a3.unknownParameter, + headers, + cookies: __privateGet(this, _cookies, cookies_get), + headersSize: (0, NetworkUtils_js_1.computeHeadersSize)(headers), + bodySize: __privateGet(this, _bodySize, bodySize_get), + timings: __privateGet(this, _timings, timings_get), + // @ts-expect-error CDP-specific attribute. + "goog:postData": __privateGet(this, _request).info?.request?.postData, + "goog:hasPostData": __privateGet(this, _request).info?.request?.hasPostData, + "goog:resourceType": __privateGet(this, _request).info?.type + }; + }; + _getBeforeRequestEvent = new WeakSet(); + getBeforeRequestEvent_fn = function() { + var _a4; + (0, assert_js_1.assert)(__privateGet(this, _request).info, "RequestWillBeSentEvent is not set"); + return { + method: protocol_js_1.ChromiumBidi.Network.EventNames.BeforeRequestSent, + params: { + ...__privateMethod(this, _getBaseEventParams, getBaseEventParams_fn).call(this, "beforeRequestSent"), + initiator: { + type: __privateMethod(_a4 = _a3, _getInitiatorType, getInitiatorType_fn).call(_a4, __privateGet(this, _request).info.initiator.type), + columnNumber: __privateGet(this, _request).info.initiator.columnNumber, + lineNumber: __privateGet(this, _request).info.initiator.lineNumber, + stackTrace: __privateGet(this, _request).info.initiator.stack, + request: __privateGet(this, _request).info.initiator.requestId + } + } + }; + }; + _getResponseStartedEvent = new WeakSet(); + getResponseStartedEvent_fn = function() { + return { + method: protocol_js_1.ChromiumBidi.Network.EventNames.ResponseStarted, + params: { + ...__privateMethod(this, _getBaseEventParams, getBaseEventParams_fn).call(this, "responseStarted"), + response: __privateMethod(this, _getResponseEventParams, getResponseEventParams_fn).call(this) + } + }; + }; + _getResponseReceivedEvent = new WeakSet(); + getResponseReceivedEvent_fn = function() { + return { + method: protocol_js_1.ChromiumBidi.Network.EventNames.ResponseCompleted, + params: { + ...__privateMethod(this, _getBaseEventParams, getBaseEventParams_fn).call(this), + response: __privateMethod(this, _getResponseEventParams, getResponseEventParams_fn).call(this) + } + }; + }; + _isIgnoredEvent = new WeakSet(); + isIgnoredEvent_fn = function() { + const faviconUrl = "/favicon.ico"; + return __privateGet(this, _request).paused?.request.url.endsWith(faviconUrl) ?? __privateGet(this, _request).info?.request.url.endsWith(faviconUrl) ?? false; + }; + _getOverrideHeader = new WeakSet(); + getOverrideHeader_fn = function(headers, cookies) { + if (!headers && !cookies) { + return void 0; + } + let overrideHeaders = headers; + const cookieHeader = (0, NetworkUtils_js_1.networkHeaderFromCookieHeaders)(cookies); + if (cookieHeader && !overrideHeaders) { + overrideHeaders = __privateGet(this, _requestHeaders, requestHeaders_get); + } + if (cookieHeader && overrideHeaders) { + overrideHeaders.filter((header) => header.name.localeCompare("cookie", void 0, { + sensitivity: "base" + }) !== 0); + overrideHeaders.push(cookieHeader); + } + return overrideHeaders; + }; + _getInitiatorType = new WeakSet(); + getInitiatorType_fn = function(initiatorType) { + switch (initiatorType) { + case "parser": + case "script": + case "preflight": + return initiatorType; + default: + return "other"; + } + }; + __privateAdd(NetworkRequest, _getInitiatorType); + __publicField(NetworkRequest, "unknownParameter", "UNKNOWN"); + exports.NetworkRequest = NetworkRequest; + _a3 = NetworkRequest; + function getCdpBodyFromBiDiBytesValue(body) { + let parsedBody; + if (body?.type === "string") { + parsedBody = btoa(body.value); + } else if (body?.type === "base64") { + parsedBody = body.value; + } + return parsedBody; + } + function getSizeFromBiDiBytesValue(body) { + if (body?.type === "string") { + return body.value.length; + } else if (body?.type === "base64") { + return atob(body.value).length; + } + return 0; + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/network/NetworkStorage.js +var require_NetworkStorage = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/network/NetworkStorage.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.NetworkStorage = void 0; + var protocol_js_1 = require_protocol(); + var uuid_js_1 = require_uuid(); + var NetworkRequest_js_1 = require_NetworkRequest(); + var NetworkUtils_js_1 = require_NetworkUtils(); + var NetworkStorage = class { + #browsingContextStorage; + #eventManager; + #logger; + /** + * A map from network request ID to Network Request objects. + * Needed as long as information about requests comes from different events. + */ + #requests = /* @__PURE__ */ new Map(); + /** A map from intercept ID to track active network intercepts. */ + #intercepts = /* @__PURE__ */ new Map(); + #defaultCacheBehavior = "default"; + constructor(eventManager, browsingContextStorage, browserClient, logger) { + this.#browsingContextStorage = browsingContextStorage; + this.#eventManager = eventManager; + browserClient.on("Target.detachedFromTarget", ({ sessionId }) => { + this.disposeRequestMap(sessionId); + }); + this.#logger = logger; + } + /** + * Gets the network request with the given ID, if any. + * Otherwise, creates a new network request with the given ID and cdp target. + */ + #getOrCreateNetworkRequest(id, cdpTarget, redirectCount) { + let request = this.getRequestById(id); + if (request) { + return request; + } + request = new NetworkRequest_js_1.NetworkRequest(id, this.#eventManager, this, cdpTarget, redirectCount, this.#logger); + this.addRequest(request); + return request; + } + onCdpTargetCreated(cdpTarget) { + const cdpClient = cdpTarget.cdpClient; + const listeners = [ + [ + "Network.requestWillBeSent", + (params) => { + const request = this.getRequestById(params.requestId); + if (request && request.isRedirecting()) { + request.handleRedirect(params); + this.deleteRequest(params.requestId); + this.#getOrCreateNetworkRequest(params.requestId, cdpTarget, request.redirectCount + 1).onRequestWillBeSentEvent(params); + } else { + this.#getOrCreateNetworkRequest(params.requestId, cdpTarget).onRequestWillBeSentEvent(params); + } + } + ], + [ + "Network.requestWillBeSentExtraInfo", + (params) => { + this.#getOrCreateNetworkRequest(params.requestId, cdpTarget).onRequestWillBeSentExtraInfoEvent(params); + } + ], + [ + "Network.responseReceived", + (params) => { + this.#getOrCreateNetworkRequest(params.requestId, cdpTarget).onResponseReceivedEvent(params); + } + ], + [ + "Network.responseReceivedExtraInfo", + (params) => { + this.#getOrCreateNetworkRequest(params.requestId, cdpTarget).onResponseReceivedExtraInfoEvent(params); + } + ], + [ + "Network.requestServedFromCache", + (params) => { + this.#getOrCreateNetworkRequest(params.requestId, cdpTarget).onServedFromCache(); + } + ], + [ + "Network.loadingFailed", + (params) => { + this.#getOrCreateNetworkRequest(params.requestId, cdpTarget).onLoadingFailedEvent(params); + } + ], + [ + "Fetch.requestPaused", + (event) => { + this.#getOrCreateNetworkRequest( + // CDP quirk if the Network domain is not present this is undefined + event.networkId ?? event.requestId, + cdpTarget + ).onRequestPaused(event); + } + ], + [ + "Fetch.authRequired", + (event) => { + let request = this.getRequestByFetchId(event.requestId); + if (!request) { + request = this.#getOrCreateNetworkRequest(event.requestId, cdpTarget); + } + request.onAuthRequired(event); + } + ] + ]; + for (const [event, listener] of listeners) { + cdpClient.on(event, listener); + } + } + getInterceptionStages(browsingContextId) { + const stages = { + request: false, + response: false, + auth: false + }; + for (const intercept of this.#intercepts.values()) { + if (intercept.contexts && !intercept.contexts.includes(browsingContextId)) { + continue; + } + stages.request ||= intercept.phases.includes( + "beforeRequestSent" + /* Network.InterceptPhase.BeforeRequestSent */ + ); + stages.response ||= intercept.phases.includes( + "responseStarted" + /* Network.InterceptPhase.ResponseStarted */ + ); + stages.auth ||= intercept.phases.includes( + "authRequired" + /* Network.InterceptPhase.AuthRequired */ + ); + } + return stages; + } + getInterceptsForPhase(request, phase) { + if (request.url === NetworkRequest_js_1.NetworkRequest.unknownParameter) { + return /* @__PURE__ */ new Set(); + } + const intercepts = /* @__PURE__ */ new Set(); + for (const [interceptId, intercept] of this.#intercepts.entries()) { + if (!intercept.phases.includes(phase) || intercept.contexts && !intercept.contexts.includes(request.cdpTarget.topLevelId)) { + continue; + } + if (intercept.urlPatterns.length === 0) { + intercepts.add(interceptId); + continue; + } + for (const pattern of intercept.urlPatterns) { + if ((0, NetworkUtils_js_1.matchUrlPattern)(pattern, request.url)) { + intercepts.add(interceptId); + break; + } + } + } + return intercepts; + } + disposeRequestMap(sessionId) { + for (const request of this.#requests.values()) { + if (request.cdpClient.sessionId === sessionId) { + this.#requests.delete(request.id); + } + } + } + /** + * Adds the given entry to the intercept map. + * URL patterns are assumed to be parsed. + * + * @return The intercept ID. + */ + addIntercept(value) { + const interceptId = (0, uuid_js_1.uuidv4)(); + this.#intercepts.set(interceptId, value); + return interceptId; + } + /** + * Removes the given intercept from the intercept map. + * Throws NoSuchInterceptException if the intercept does not exist. + */ + removeIntercept(intercept) { + if (!this.#intercepts.has(intercept)) { + throw new protocol_js_1.NoSuchInterceptException(`Intercept '${intercept}' does not exist.`); + } + this.#intercepts.delete(intercept); + } + getRequestById(id) { + return this.#requests.get(id); + } + getRequestByFetchId(fetchId) { + for (const request of this.#requests.values()) { + if (request.fetchId === fetchId) { + return request; + } + } + return; + } + addRequest(request) { + this.#requests.set(request.id, request); + } + deleteRequest(id) { + this.#requests.delete(id); + } + /** + * Gets the virtual navigation ID for the given navigable ID. + */ + getNavigationId(contextId) { + if (contextId === void 0) { + return null; + } + return this.#browsingContextStorage.findContext(contextId)?.navigationId ?? null; + } + set defaultCacheBehavior(behavior) { + this.#defaultCacheBehavior = behavior; + } + get defaultCacheBehavior() { + return this.#defaultCacheBehavior; + } + }; + exports.NetworkStorage = NetworkStorage; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/PreloadScriptStorage.js +var require_PreloadScriptStorage = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/PreloadScriptStorage.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.PreloadScriptStorage = void 0; + var PreloadScriptStorage = class { + /** Tracks all BiDi preload scripts. */ + #scripts = /* @__PURE__ */ new Set(); + /** + * Finds all entries that match the given filter (OR logic). + */ + find(filter2) { + if (!filter2) { + return [...this.#scripts]; + } + return [...this.#scripts].filter((script) => { + if (filter2.id !== void 0 && filter2.id === script.id) { + return true; + } + if (filter2.targetId !== void 0 && script.targetIds.has(filter2.targetId)) { + return true; + } + if (filter2.global !== void 0 && // Global scripts have no contexts + (filter2.global && script.contexts === void 0 || // Non global scripts always have contexts + !filter2.global && script.contexts !== void 0)) { + return true; + } + return false; + }); + } + add(preloadScript) { + this.#scripts.add(preloadScript); + } + /** Deletes all BiDi preload script entries that match the given filter. */ + remove(filter2) { + for (const preloadScript of this.find(filter2)) { + this.#scripts.delete(preloadScript); + } + } + }; + exports.PreloadScriptStorage = PreloadScriptStorage; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/RealmStorage.js +var require_RealmStorage = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/script/RealmStorage.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.RealmStorage = void 0; + var protocol_js_1 = require_protocol(); + var WindowRealm_js_1 = require_WindowRealm(); + var RealmStorage = class { + /** Tracks handles and their realms sent to the client. */ + #knownHandlesToRealmMap = /* @__PURE__ */ new Map(); + /** Map from realm ID to Realm. */ + #realmMap = /* @__PURE__ */ new Map(); + get knownHandlesToRealmMap() { + return this.#knownHandlesToRealmMap; + } + addRealm(realm) { + this.#realmMap.set(realm.realmId, realm); + } + /** Finds all realms that match the given filter. */ + findRealms(filter2) { + return Array.from(this.#realmMap.values()).filter((realm) => { + if (filter2.realmId !== void 0 && filter2.realmId !== realm.realmId) { + return false; + } + if (filter2.browsingContextId !== void 0 && !realm.associatedBrowsingContexts.map((browsingContext) => browsingContext.id).includes(filter2.browsingContextId)) { + return false; + } + if (filter2.sandbox !== void 0 && (!(realm instanceof WindowRealm_js_1.WindowRealm) || filter2.sandbox !== realm.sandbox)) { + return false; + } + if (filter2.executionContextId !== void 0 && filter2.executionContextId !== realm.executionContextId) { + return false; + } + if (filter2.origin !== void 0 && filter2.origin !== realm.origin) { + return false; + } + if (filter2.type !== void 0 && filter2.type !== realm.realmType) { + return false; + } + if (filter2.cdpSessionId !== void 0 && filter2.cdpSessionId !== realm.cdpClient.sessionId) { + return false; + } + return true; + }); + } + findRealm(filter2) { + const maybeRealms = this.findRealms(filter2); + if (maybeRealms.length !== 1) { + return void 0; + } + return maybeRealms[0]; + } + /** Gets the only realm that matches the given filter, if any, otherwise throws. */ + getRealm(filter2) { + const maybeRealm = this.findRealm(filter2); + if (maybeRealm === void 0) { + throw new protocol_js_1.NoSuchFrameException(`Realm ${JSON.stringify(filter2)} not found`); + } + return maybeRealm; + } + /** Deletes all realms that match the given filter. */ + deleteRealms(filter2) { + this.findRealms(filter2).map((realm) => { + realm.dispose(); + this.#realmMap.delete(realm.realmId); + Array.from(this.knownHandlesToRealmMap.entries()).filter(([, r]) => r === realm.realmId).map(([handle]) => this.knownHandlesToRealmMap.delete(handle)); + }); + } + }; + exports.RealmStorage = RealmStorage; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/Buffer.js +var require_Buffer = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/Buffer.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Buffer = void 0; + var Buffer2 = class { + #capacity; + #entries = []; + #onItemRemoved; + /** + * @param capacity The buffer capacity. + * @param onItemRemoved Delegate called for each removed element. + */ + constructor(capacity, onItemRemoved) { + this.#capacity = capacity; + this.#onItemRemoved = onItemRemoved; + } + get() { + return this.#entries; + } + add(value) { + this.#entries.push(value); + while (this.#entries.length > this.#capacity) { + const item = this.#entries.shift(); + if (item !== void 0) { + this.#onItemRemoved?.(item); + } + } + } + }; + exports.Buffer = Buffer2; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/DefaultMap.js +var require_DefaultMap = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/DefaultMap.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.DefaultMap = void 0; + var DefaultMap = class extends Map { + /** The default value to return whenever a key is not present in the map. */ + #getDefaultValue; + constructor(getDefaultValue, entries) { + super(entries); + this.#getDefaultValue = getDefaultValue; + } + get(key) { + if (!this.has(key)) { + this.set(key, this.#getDefaultValue(key)); + } + return super.get(key); + } + }; + exports.DefaultMap = DefaultMap; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/DistinctValues.js +var require_DistinctValues = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/DistinctValues.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.distinctValues = distinctValues; + exports.deterministicJSONStringify = deterministicJSONStringify; + function distinctValues(values) { + const map2 = /* @__PURE__ */ new Map(); + for (const value of values) { + map2.set(deterministicJSONStringify(value), value); + } + return Array.from(map2.values()); + } + function deterministicJSONStringify(obj) { + return JSON.stringify(normalizeObject(obj)); + } + function normalizeObject(obj) { + if (obj === void 0 || obj === null || Array.isArray(obj) || typeof obj !== "object") { + return obj; + } + const newObj = {}; + for (const key of Object.keys(obj).sort()) { + const value = obj[key]; + newObj[key] = normalizeObject(value); + } + return newObj; + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/utils/IdWrapper.js +var require_IdWrapper = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/utils/IdWrapper.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.IdWrapper = void 0; + var _counter, _id; + var _IdWrapper = class { + constructor() { + __privateAdd(this, _id, void 0); + __privateSet(this, _id, ++__privateWrapper(_IdWrapper, _counter)._); + } + get id() { + return __privateGet(this, _id); + } + }; + var IdWrapper = _IdWrapper; + _counter = new WeakMap(); + _id = new WeakMap(); + __privateAdd(IdWrapper, _counter, 0); + exports.IdWrapper = IdWrapper; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/session/events.js +var require_events = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/session/events.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isCdpEvent = isCdpEvent2; + exports.assertSupportedEvent = assertSupportedEvent; + var protocol_js_1 = require_protocol(); + function isCdpEvent2(name) { + return name.split(".").at(0)?.startsWith(protocol_js_1.ChromiumBidi.BiDiModule.Cdp) ?? false; + } + function assertSupportedEvent(name) { + if (!protocol_js_1.ChromiumBidi.EVENT_NAMES.has(name) && !isCdpEvent2(name)) { + throw new protocol_js_1.InvalidArgumentException(`Unknown event: ${name}`); + } + } + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/session/SubscriptionManager.js +var require_SubscriptionManager = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/session/SubscriptionManager.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SubscriptionManager = void 0; + exports.cartesianProduct = cartesianProduct; + exports.unrollEvents = unrollEvents; + var protocol_js_1 = require_protocol(); + var events_js_1 = require_events(); + function cartesianProduct(...a) { + return a.reduce((a2, b) => a2.flatMap((d) => b.map((e) => [d, e].flat()))); + } + function unrollEvents(events) { + const allEvents = /* @__PURE__ */ new Set(); + function addEvents(events2) { + for (const event of events2) { + allEvents.add(event); + } + } + for (const event of events) { + switch (event) { + case protocol_js_1.ChromiumBidi.BiDiModule.Bluetooth: + addEvents(Object.values(protocol_js_1.ChromiumBidi.Bluetooth.EventNames)); + break; + case protocol_js_1.ChromiumBidi.BiDiModule.BrowsingContext: + addEvents(Object.values(protocol_js_1.ChromiumBidi.BrowsingContext.EventNames)); + break; + case protocol_js_1.ChromiumBidi.BiDiModule.Log: + addEvents(Object.values(protocol_js_1.ChromiumBidi.Log.EventNames)); + break; + case protocol_js_1.ChromiumBidi.BiDiModule.Network: + addEvents(Object.values(protocol_js_1.ChromiumBidi.Network.EventNames)); + break; + case protocol_js_1.ChromiumBidi.BiDiModule.Script: + addEvents(Object.values(protocol_js_1.ChromiumBidi.Script.EventNames)); + break; + default: + allEvents.add(event); + } + } + return [...allEvents.values()]; + } + var SubscriptionManager = class { + #subscriptionPriority = 0; + // BrowsingContext `null` means the event has subscription across all the + // browsing contexts. + // Channel `null` means no `channel` should be added. + #channelToContextToEventMap = /* @__PURE__ */ new Map(); + #browsingContextStorage; + constructor(browsingContextStorage) { + this.#browsingContextStorage = browsingContextStorage; + } + getChannelsSubscribedToEvent(eventMethod, contextId) { + const prioritiesAndChannels = Array.from(this.#channelToContextToEventMap.keys()).map((channel) => ({ + priority: this.#getEventSubscriptionPriorityForChannel(eventMethod, contextId, channel), + channel + })).filter(({ priority }) => priority !== null); + return prioritiesAndChannels.sort((a, b) => a.priority - b.priority).map(({ channel }) => channel); + } + #getEventSubscriptionPriorityForChannel(eventMethod, contextId, channel) { + const contextToEventMap = this.#channelToContextToEventMap.get(channel); + if (contextToEventMap === void 0) { + return null; + } + const maybeTopLevelContextId = this.#browsingContextStorage.findTopLevelContextId(contextId); + const relevantContexts = [.../* @__PURE__ */ new Set([null, maybeTopLevelContextId])]; + const priorities = relevantContexts.map((context) => { + const priority = contextToEventMap.get(context)?.get(eventMethod); + if ((0, events_js_1.isCdpEvent)(eventMethod)) { + const cdpPriority = contextToEventMap.get(context)?.get(protocol_js_1.ChromiumBidi.BiDiModule.Cdp); + return priority && cdpPriority ? Math.min(priority, cdpPriority) : ( + // At this point we know that we have subscribed + // to only one of the two + priority ?? cdpPriority + ); + } + return priority; + }).filter((p) => p !== void 0); + if (priorities.length === 0) { + return null; + } + return Math.min(...priorities); + } + /** + * @param module BiDi+ module + * @param contextId `null` == globally subscribed + * + * @returns + */ + isSubscribedTo(moduleOrEvent, contextId = null) { + const topLevelContext = this.#browsingContextStorage.findTopLevelContextId(contextId); + for (const browserContextToEventMap of this.#channelToContextToEventMap.values()) { + for (const [id, eventMap] of browserContextToEventMap.entries()) { + if (topLevelContext !== id && id !== null) { + continue; + } + for (const event of eventMap.keys()) { + if ( + // Event explicitly subscribed + event === moduleOrEvent || // Event subscribed via module + event === moduleOrEvent.split(".").at(0) || // Event explicitly subscribed compared to module + event.split(".").at(0) === moduleOrEvent + ) { + return true; + } + } + } + } + return false; + } + /** + * Subscribes to event in the given context and channel. + * @param {EventNames} event + * @param {BrowsingContext.BrowsingContext | null} contextId + * @param {BidiPlusChannel} channel + * @return {SubscriptionItem[]} List of + * subscriptions. If the event is a whole module, it will return all the specific + * events. If the contextId is null, it will return all the top-level contexts which were + * not subscribed before the command. + */ + subscribe(event, contextId, channel) { + contextId = this.#browsingContextStorage.findTopLevelContextId(contextId); + switch (event) { + case protocol_js_1.ChromiumBidi.BiDiModule.BrowsingContext: + return Object.values(protocol_js_1.ChromiumBidi.BrowsingContext.EventNames).map((specificEvent) => this.subscribe(specificEvent, contextId, channel)).flat(); + case protocol_js_1.ChromiumBidi.BiDiModule.Log: + return Object.values(protocol_js_1.ChromiumBidi.Log.EventNames).map((specificEvent) => this.subscribe(specificEvent, contextId, channel)).flat(); + case protocol_js_1.ChromiumBidi.BiDiModule.Network: + return Object.values(protocol_js_1.ChromiumBidi.Network.EventNames).map((specificEvent) => this.subscribe(specificEvent, contextId, channel)).flat(); + case protocol_js_1.ChromiumBidi.BiDiModule.Script: + return Object.values(protocol_js_1.ChromiumBidi.Script.EventNames).map((specificEvent) => this.subscribe(specificEvent, contextId, channel)).flat(); + case protocol_js_1.ChromiumBidi.BiDiModule.Bluetooth: + return Object.values(protocol_js_1.ChromiumBidi.Bluetooth.EventNames).map((specificEvent) => this.subscribe(specificEvent, contextId, channel)).flat(); + default: + } + if (!this.#channelToContextToEventMap.has(channel)) { + this.#channelToContextToEventMap.set(channel, /* @__PURE__ */ new Map()); + } + const contextToEventMap = this.#channelToContextToEventMap.get(channel); + if (!contextToEventMap.has(contextId)) { + contextToEventMap.set(contextId, /* @__PURE__ */ new Map()); + } + const eventMap = contextToEventMap.get(contextId); + const affectedContextIds = (contextId === null ? this.#browsingContextStorage.getTopLevelContexts().map((c) => c.id) : [contextId]).filter((contextId2) => !this.isSubscribedTo(event, contextId2)); + if (!eventMap.has(event)) { + eventMap.set(event, this.#subscriptionPriority++); + } + return affectedContextIds.map((contextId2) => ({ + event, + contextId: contextId2 + })); + } + /** + * Unsubscribes atomically from all events in the given contexts and channel. + */ + unsubscribeAll(events, contextIds, channel) { + for (const contextId of contextIds) { + if (contextId !== null) { + this.#browsingContextStorage.getContext(contextId); + } + } + const eventContextPairs = cartesianProduct(unrollEvents(events), contextIds); + eventContextPairs.map(([event, contextId]) => this.#checkUnsubscribe(event, contextId, channel)).forEach((unsubscribe) => unsubscribe()); + } + /** + * Unsubscribes from the event in the given context and channel. + * Syntactic sugar for "unsubscribeAll". + */ + unsubscribe(eventName, contextId, channel) { + this.unsubscribeAll([eventName], [contextId], channel); + } + #checkUnsubscribe(event, contextId, channel) { + contextId = this.#browsingContextStorage.findTopLevelContextId(contextId); + if (!this.#channelToContextToEventMap.has(channel)) { + throw new protocol_js_1.InvalidArgumentException(`Cannot unsubscribe from ${event}, ${contextId === null ? "null" : contextId}. No subscription found.`); + } + const contextToEventMap = this.#channelToContextToEventMap.get(channel); + if (!contextToEventMap.has(contextId)) { + throw new protocol_js_1.InvalidArgumentException(`Cannot unsubscribe from ${event}, ${contextId === null ? "null" : contextId}. No subscription found.`); + } + const eventMap = contextToEventMap.get(contextId); + if (!eventMap.has(event)) { + throw new protocol_js_1.InvalidArgumentException(`Cannot unsubscribe from ${event}, ${contextId === null ? "null" : contextId}. No subscription found.`); + } + return () => { + eventMap.delete(event); + if (eventMap.size === 0) { + contextToEventMap.delete(event); + } + if (contextToEventMap.size === 0) { + this.#channelToContextToEventMap.delete(channel); + } + }; + } + }; + exports.SubscriptionManager = SubscriptionManager; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/session/EventManager.js +var require_EventManager = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/modules/session/EventManager.js"(exports) { + "use strict"; + init_cjs_shim(); + var _a3; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.EventManager = void 0; + var protocol_js_1 = require_protocol(); + var Buffer_js_1 = require_Buffer(); + var DefaultMap_js_1 = require_DefaultMap(); + var DistinctValues_js_1 = require_DistinctValues(); + var EventEmitter_js_1 = require_EventEmitter(); + var IdWrapper_js_1 = require_IdWrapper(); + var OutgoingMessage_js_1 = require_OutgoingMessage(); + var events_js_1 = require_events(); + var SubscriptionManager_js_1 = require_SubscriptionManager(); + var EventWrapper = class { + #idWrapper = new IdWrapper_js_1.IdWrapper(); + #contextId; + #event; + constructor(event, contextId) { + this.#event = event; + this.#contextId = contextId; + } + get id() { + return this.#idWrapper.id; + } + get contextId() { + return this.#contextId; + } + get event() { + return this.#event; + } + }; + var eventBufferLength = /* @__PURE__ */ new Map([[protocol_js_1.ChromiumBidi.Log.EventNames.LogEntryAdded, 100]]); + var _eventToContextsMap, _eventBuffers, _lastMessageSent, _subscriptionManager, _browsingContextStorage, _subscribeHooks, _getMapKey, getMapKey_fn, _bufferEvent, bufferEvent_fn, _markEventSent, markEventSent_fn, _getBufferedEvents, getBufferedEvents_fn; + var EventManager = class extends EventEmitter_js_1.EventEmitter { + constructor(browsingContextStorage) { + super(); + /** + * If the event is buffer-able, put it in the buffer. + */ + __privateAdd(this, _bufferEvent); + /** + * If the event is buffer-able, mark it as sent to the given contextId and channel. + */ + __privateAdd(this, _markEventSent); + /** + * Returns events which are buffered and not yet sent to the given channel events. + */ + __privateAdd(this, _getBufferedEvents); + /** + * Maps event name to a set of contexts where this event already happened. + * Needed for getting buffered events from all the contexts in case of + * subscripting to all contexts. + */ + __privateAdd(this, _eventToContextsMap, new DefaultMap_js_1.DefaultMap(() => /* @__PURE__ */ new Set())); + /** + * Maps `eventName` + `browsingContext` to buffer. Used to get buffered events + * during subscription. Channel-agnostic. + */ + __privateAdd(this, _eventBuffers, /* @__PURE__ */ new Map()); + /** + * Maps `eventName` + `browsingContext` to Map of channel to last id + * Used to avoid sending duplicated events when user + * subscribes -> unsubscribes -> subscribes. + */ + __privateAdd(this, _lastMessageSent, /* @__PURE__ */ new Map()); + __privateAdd(this, _subscriptionManager, void 0); + __privateAdd(this, _browsingContextStorage, void 0); + /** + * Map of event name to hooks to be called when client is subscribed to the event. + */ + __privateAdd(this, _subscribeHooks, void 0); + __privateSet(this, _browsingContextStorage, browsingContextStorage); + __privateSet(this, _subscriptionManager, new SubscriptionManager_js_1.SubscriptionManager(browsingContextStorage)); + __privateSet(this, _subscribeHooks, new DefaultMap_js_1.DefaultMap(() => [])); + } + get subscriptionManager() { + return __privateGet(this, _subscriptionManager); + } + addSubscribeHook(event, hook) { + __privateGet(this, _subscribeHooks).get(event).push(hook); + } + registerEvent(event, contextId) { + this.registerPromiseEvent(Promise.resolve({ + kind: "success", + value: event + }), contextId, event.method); + } + registerPromiseEvent(event, contextId, eventName) { + const eventWrapper = new EventWrapper(event, contextId); + const sortedChannels = __privateGet(this, _subscriptionManager).getChannelsSubscribedToEvent(eventName, contextId); + __privateMethod(this, _bufferEvent, bufferEvent_fn).call(this, eventWrapper, eventName); + for (const channel of sortedChannels) { + this.emit("event", { + message: OutgoingMessage_js_1.OutgoingMessage.createFromPromise(event, channel), + event: eventName + }); + __privateMethod(this, _markEventSent, markEventSent_fn).call(this, eventWrapper, channel, eventName); + } + } + async subscribe(eventNames, contextIds, channel) { + for (const name of eventNames) { + (0, events_js_1.assertSupportedEvent)(name); + } + for (const contextId of contextIds) { + if (contextId !== null) { + __privateGet(this, _browsingContextStorage).getContext(contextId); + } + } + const addedSubscriptionItems = []; + for (const eventName of eventNames) { + for (const contextId of contextIds) { + addedSubscriptionItems.push(...__privateGet(this, _subscriptionManager).subscribe(eventName, contextId, channel)); + for (const eventWrapper of __privateMethod(this, _getBufferedEvents, getBufferedEvents_fn).call(this, eventName, contextId, channel)) { + this.emit("event", { + message: OutgoingMessage_js_1.OutgoingMessage.createFromPromise(eventWrapper.event, channel), + event: eventName + }); + __privateMethod(this, _markEventSent, markEventSent_fn).call(this, eventWrapper, channel, eventName); + } + } + } + (0, DistinctValues_js_1.distinctValues)(addedSubscriptionItems).forEach(({ contextId, event }) => { + __privateGet(this, _subscribeHooks).get(event).forEach((hook) => hook(contextId)); + }); + await this.toggleModulesIfNeeded(); + } + async unsubscribe(eventNames, contextIds, channel) { + for (const name of eventNames) { + (0, events_js_1.assertSupportedEvent)(name); + } + __privateGet(this, _subscriptionManager).unsubscribeAll(eventNames, contextIds, channel); + await this.toggleModulesIfNeeded(); + } + async toggleModulesIfNeeded() { + await Promise.all(__privateGet(this, _browsingContextStorage).getAllContexts().map(async (context) => { + return await context.toggleModulesIfNeeded(); + })); + } + clearBufferedEvents(contextId) { + var _a4; + for (const eventName of eventBufferLength.keys()) { + const bufferMapKey = __privateMethod(_a4 = _a3, _getMapKey, getMapKey_fn).call(_a4, eventName, contextId); + __privateGet(this, _eventBuffers).delete(bufferMapKey); + } + } + }; + _eventToContextsMap = new WeakMap(); + _eventBuffers = new WeakMap(); + _lastMessageSent = new WeakMap(); + _subscriptionManager = new WeakMap(); + _browsingContextStorage = new WeakMap(); + _subscribeHooks = new WeakMap(); + _getMapKey = new WeakSet(); + getMapKey_fn = function(eventName, browsingContext) { + return JSON.stringify({ eventName, browsingContext }); + }; + _bufferEvent = new WeakSet(); + bufferEvent_fn = function(eventWrapper, eventName) { + var _a4; + if (!eventBufferLength.has(eventName)) { + return; + } + const bufferMapKey = __privateMethod(_a4 = _a3, _getMapKey, getMapKey_fn).call(_a4, eventName, eventWrapper.contextId); + if (!__privateGet(this, _eventBuffers).has(bufferMapKey)) { + __privateGet(this, _eventBuffers).set(bufferMapKey, new Buffer_js_1.Buffer(eventBufferLength.get(eventName))); + } + __privateGet(this, _eventBuffers).get(bufferMapKey).add(eventWrapper); + __privateGet(this, _eventToContextsMap).get(eventName).add(eventWrapper.contextId); + }; + _markEventSent = new WeakSet(); + markEventSent_fn = function(eventWrapper, channel, eventName) { + var _a4; + if (!eventBufferLength.has(eventName)) { + return; + } + const lastSentMapKey = __privateMethod(_a4 = _a3, _getMapKey, getMapKey_fn).call(_a4, eventName, eventWrapper.contextId); + const lastId = Math.max(__privateGet(this, _lastMessageSent).get(lastSentMapKey)?.get(channel) ?? 0, eventWrapper.id); + const channelMap = __privateGet(this, _lastMessageSent).get(lastSentMapKey); + if (channelMap) { + channelMap.set(channel, lastId); + } else { + __privateGet(this, _lastMessageSent).set(lastSentMapKey, /* @__PURE__ */ new Map([[channel, lastId]])); + } + }; + _getBufferedEvents = new WeakSet(); + getBufferedEvents_fn = function(eventName, contextId, channel) { + var _a4; + const bufferMapKey = __privateMethod(_a4 = _a3, _getMapKey, getMapKey_fn).call(_a4, eventName, contextId); + const lastSentMessageId = __privateGet(this, _lastMessageSent).get(bufferMapKey)?.get(channel) ?? -Infinity; + const result = __privateGet(this, _eventBuffers).get(bufferMapKey)?.get().filter((wrapper) => wrapper.id > lastSentMessageId) ?? []; + if (contextId === null) { + Array.from(__privateGet(this, _eventToContextsMap).get(eventName).keys()).filter((_contextId) => ( + // Events without context are already in the result. + _contextId !== null && // Events from deleted contexts should not be sent. + __privateGet(this, _browsingContextStorage).hasContext(_contextId) + )).map((_contextId) => __privateMethod(this, _getBufferedEvents, getBufferedEvents_fn).call(this, eventName, _contextId, channel)).forEach((events) => result.push(...events)); + } + return result.sort((e1, e2) => e1.id - e2.id); + }; + /** + * Returns consistent key to be used to access value maps. + */ + __privateAdd(EventManager, _getMapKey); + exports.EventManager = EventManager; + _a3 = EventManager; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/BidiServer.js +var require_BidiServer = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/BidiServer.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BidiServer = void 0; + var EventEmitter_js_1 = require_EventEmitter(); + var log_js_1 = require_log(); + var ProcessingQueue_js_1 = require_ProcessingQueue(); + var CommandProcessor_js_1 = require_CommandProcessor(); + var BluetoothProcessor_js_1 = require_BluetoothProcessor(); + var CdpTargetManager_js_1 = require_CdpTargetManager(); + var BrowsingContextStorage_js_1 = require_BrowsingContextStorage(); + var NetworkStorage_js_1 = require_NetworkStorage(); + var PreloadScriptStorage_js_1 = require_PreloadScriptStorage(); + var RealmStorage_js_1 = require_RealmStorage(); + var EventManager_js_1 = require_EventManager(); + var BidiServer2 = class extends EventEmitter_js_1.EventEmitter { + #messageQueue; + #transport; + #commandProcessor; + #eventManager; + #browsingContextStorage = new BrowsingContextStorage_js_1.BrowsingContextStorage(); + #realmStorage = new RealmStorage_js_1.RealmStorage(); + #preloadScriptStorage = new PreloadScriptStorage_js_1.PreloadScriptStorage(); + #bluetoothProcessor; + #logger; + #handleIncomingMessage = (message) => { + void this.#commandProcessor.processCommand(message).catch((error) => { + this.#logger?.(log_js_1.LogType.debugError, error); + }); + }; + #processOutgoingMessage = async (messageEntry) => { + const message = messageEntry.message; + if (messageEntry.channel !== null) { + message["channel"] = messageEntry.channel; + } + await this.#transport.sendMessage(message); + }; + constructor(bidiTransport, cdpConnection, browserCdpClient, selfTargetId, defaultUserContextId, parser, logger) { + super(); + this.#logger = logger; + this.#messageQueue = new ProcessingQueue_js_1.ProcessingQueue(this.#processOutgoingMessage, this.#logger); + this.#transport = bidiTransport; + this.#transport.setOnMessage(this.#handleIncomingMessage); + this.#eventManager = new EventManager_js_1.EventManager(this.#browsingContextStorage); + const networkStorage = new NetworkStorage_js_1.NetworkStorage(this.#eventManager, this.#browsingContextStorage, browserCdpClient, logger); + this.#bluetoothProcessor = new BluetoothProcessor_js_1.BluetoothProcessor(this.#eventManager, this.#browsingContextStorage); + this.#commandProcessor = new CommandProcessor_js_1.CommandProcessor(cdpConnection, browserCdpClient, this.#eventManager, this.#browsingContextStorage, this.#realmStorage, this.#preloadScriptStorage, networkStorage, this.#bluetoothProcessor, parser, async (options) => { + await browserCdpClient.sendCommand("Security.setIgnoreCertificateErrors", { + ignore: options.acceptInsecureCerts ?? false + }); + new CdpTargetManager_js_1.CdpTargetManager(cdpConnection, browserCdpClient, selfTargetId, this.#eventManager, this.#browsingContextStorage, this.#realmStorage, networkStorage, this.#bluetoothProcessor, this.#preloadScriptStorage, defaultUserContextId, options?.unhandledPromptBehavior, logger); + await browserCdpClient.sendCommand("Target.setDiscoverTargets", { + discover: true + }); + await browserCdpClient.sendCommand("Target.setAutoAttach", { + autoAttach: true, + waitForDebuggerOnStart: true, + flatten: true + }); + await this.#topLevelContextsLoaded(); + }, this.#logger); + this.#eventManager.on("event", ({ message, event }) => { + this.emitOutgoingMessage(message, event); + }); + this.#commandProcessor.on("response", ({ message, event }) => { + this.emitOutgoingMessage(message, event); + }); + } + /** + * Creates and starts BiDi Mapper instance. + */ + static async createAndStart(bidiTransport, cdpConnection, browserCdpClient, selfTargetId, parser, logger) { + const [{ browserContextIds }, { targetInfos }] = await Promise.all([ + browserCdpClient.sendCommand("Target.getBrowserContexts"), + browserCdpClient.sendCommand("Target.getTargets") + ]); + let defaultUserContextId = "default"; + for (const info of targetInfos) { + if (info.browserContextId && !browserContextIds.includes(info.browserContextId)) { + defaultUserContextId = info.browserContextId; + break; + } + } + const server = new BidiServer2(bidiTransport, cdpConnection, browserCdpClient, selfTargetId, defaultUserContextId, parser, logger); + return server; + } + /** + * Sends BiDi message. + */ + emitOutgoingMessage(messageEntry, event) { + this.#messageQueue.add(messageEntry, event); + } + close() { + this.#transport.close(); + } + async #topLevelContextsLoaded() { + await Promise.all(this.#browsingContextStorage.getTopLevelContexts().map((c) => c.lifecycleLoaded())); + } + }; + exports.BidiServer = BidiServer2; + } +}); + +// ../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/BidiMapper.js +var require_BidiMapper = __commonJS({ + "../testeranto/node_modules/chromium-bidi/lib/cjs/bidiMapper/BidiMapper.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.OutgoingMessage = exports.EventEmitter = exports.BidiServer = void 0; + var BidiServer_js_1 = require_BidiServer(); + Object.defineProperty(exports, "BidiServer", { enumerable: true, get: function() { + return BidiServer_js_1.BidiServer; + } }); + var EventEmitter_js_1 = require_EventEmitter(); + Object.defineProperty(exports, "EventEmitter", { enumerable: true, get: function() { + return EventEmitter_js_1.EventEmitter; + } }); + var OutgoingMessage_js_1 = require_OutgoingMessage(); + Object.defineProperty(exports, "OutgoingMessage", { enumerable: true, get: function() { + return OutgoingMessage_js_1.OutgoingMessage; + } }); + } +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/bidi.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/BidiOverCdp.js +init_cjs_shim(); +var BidiMapper = __toESM(require_BidiMapper(), 1); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Connection.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/CDPSession.js +init_cjs_shim(); +var _detached, _connection, _sessionId; +var _BidiCdpSession = class extends CDPSession { + constructor(frame, sessionId) { + super(); + __privateAdd(this, _detached, false); + __privateAdd(this, _connection, void 0); + __privateAdd(this, _sessionId, Deferred.create()); + __publicField(this, "frame"); + /** + * @internal + */ + __publicField(this, "onClose", () => { + _BidiCdpSession.sessions.delete(this.id()); + __privateSet(this, _detached, true); + }); + this.frame = frame; + if (!this.frame.page().browser().cdpSupported) { + return; + } + const connection = this.frame.page().browser().connection; + __privateSet(this, _connection, connection); + if (sessionId) { + __privateGet(this, _sessionId).resolve(sessionId); + _BidiCdpSession.sessions.set(sessionId, this); + } else { + (async () => { + try { + const { result } = await connection.send("cdp.getSession", { + context: frame._id + }); + __privateGet(this, _sessionId).resolve(result.session); + _BidiCdpSession.sessions.set(result.session, this); + } catch (error) { + __privateGet(this, _sessionId).reject(error); + } + })(); + } + _BidiCdpSession.sessions.set(__privateGet(this, _sessionId).value(), this); + } + connection() { + return void 0; + } + async send(method, params, options) { + if (__privateGet(this, _connection) === void 0) { + throw new UnsupportedOperation("CDP support is required for this feature. The current browser does not support CDP."); + } + if (__privateGet(this, _detached)) { + throw new TargetCloseError(`Protocol error (${method}): Session closed. Most likely the page has been closed.`); + } + const session = await __privateGet(this, _sessionId).valueOrThrow(); + const { result } = await __privateGet(this, _connection).send("cdp.sendCommand", { + method, + params, + session + }, options?.timeout); + return result.result; + } + async detach() { + if (__privateGet(this, _connection) === void 0 || __privateGet(this, _connection).closed || __privateGet(this, _detached)) { + return; + } + try { + await this.frame.client.send("Target.detachFromTarget", { + sessionId: this.id() + }); + } finally { + this.onClose(); + } + } + id() { + const value = __privateGet(this, _sessionId).value(); + return typeof value === "string" ? value : ""; + } +}; +var BidiCdpSession = _BidiCdpSession; +_detached = new WeakMap(); +_connection = new WeakMap(); +_sessionId = new WeakMap(); +__publicField(BidiCdpSession, "sessions", /* @__PURE__ */ new Map()); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Connection.js +var debugProtocolSend = debug("puppeteer:webDriverBiDi:SEND \u25BA"); +var debugProtocolReceive = debug("puppeteer:webDriverBiDi:RECV \u25C0"); +var BidiConnection = class extends EventEmitter { + #url; + #transport; + #delay; + #timeout = 0; + #closed = false; + #callbacks = new CallbackRegistry(); + #emitters = []; + constructor(url, transport, delay = 0, timeout2) { + super(); + this.#url = url; + this.#delay = delay; + this.#timeout = timeout2 ?? 18e4; + this.#transport = transport; + this.#transport.onmessage = this.onMessage.bind(this); + this.#transport.onclose = this.unbind.bind(this); + } + get closed() { + return this.#closed; + } + get url() { + return this.#url; + } + pipeTo(emitter) { + this.#emitters.push(emitter); + } + emit(type, event) { + for (const emitter of this.#emitters) { + emitter.emit(type, event); + } + return super.emit(type, event); + } + send(method, params, timeout2) { + assert(!this.#closed, "Protocol error: Connection closed."); + return this.#callbacks.create(method, timeout2 ?? this.#timeout, (id) => { + const stringifiedMessage = JSON.stringify({ + id, + method, + params + }); + debugProtocolSend(stringifiedMessage); + this.#transport.send(stringifiedMessage); + }); + } + /** + * @internal + */ + async onMessage(message) { + if (this.#delay) { + await new Promise((f) => { + return setTimeout(f, this.#delay); + }); + } + debugProtocolReceive(message); + const object = JSON.parse(message); + if ("type" in object) { + switch (object.type) { + case "success": + this.#callbacks.resolve(object.id, object); + return; + case "error": + if (object.id === null) { + break; + } + this.#callbacks.reject(object.id, createProtocolError(object), `${object.error}: ${object.message}`); + return; + case "event": + if (isCdpEvent(object)) { + BidiCdpSession.sessions.get(object.params.session)?.emit(object.params.event, object.params.params); + return; + } + this.emit(object.method, object.params); + return; + } + } + if ("id" in object) { + this.#callbacks.reject(object.id, `Protocol Error. Message is not in BiDi protocol format: '${message}'`, object.message); + } + debugError(object); + } + /** + * Unbinds the connection, but keeps the transport open. Useful when the transport will + * be reused by other connection e.g. with different protocol. + * @internal + */ + unbind() { + if (this.#closed) { + return; + } + this.#closed = true; + this.#transport.onmessage = () => { + }; + this.#transport.onclose = () => { + }; + this.#callbacks.clear(); + } + /** + * Unbinds the connection and closes the transport. + */ + dispose() { + this.unbind(); + this.#transport.close(); + } + getPendingProtocolErrors() { + return this.#callbacks.getPendingProtocolErrors(); + } +}; +function createProtocolError(object) { + let message = `${object.error} ${object.message}`; + if (object.stacktrace) { + message += ` ${object.stacktrace}`; + } + return message; +} +function isCdpEvent(event) { + return event.method.startsWith("cdp."); +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/BidiOverCdp.js +var bidiServerLogger = (prefix, ...args) => { + debug(`bidi:${prefix}`)(args); +}; +async function connectBidiOverCdp(cdp) { + const transportBiDi = new NoOpTransport(); + const cdpConnectionAdapter = new CdpConnectionAdapter(cdp); + const pptrTransport = { + send(message) { + transportBiDi.emitMessage(JSON.parse(message)); + }, + close() { + bidiServer.close(); + cdpConnectionAdapter.close(); + cdp.dispose(); + }, + onmessage(_message) { + } + }; + transportBiDi.on("bidiResponse", (message) => { + pptrTransport.onmessage(JSON.stringify(message)); + }); + const pptrBiDiConnection = new BidiConnection(cdp.url(), pptrTransport, cdp.delay, cdp.timeout); + const bidiServer = await BidiMapper.BidiServer.createAndStart( + transportBiDi, + cdpConnectionAdapter, + cdpConnectionAdapter.browserClient(), + /* selfTargetId= */ + "", + void 0, + bidiServerLogger + ); + return pptrBiDiConnection; +} +var CdpConnectionAdapter = class { + #cdp; + #adapters = /* @__PURE__ */ new Map(); + #browserCdpConnection; + constructor(cdp) { + this.#cdp = cdp; + this.#browserCdpConnection = new CDPClientAdapter(cdp); + } + browserClient() { + return this.#browserCdpConnection; + } + getCdpClient(id) { + const session = this.#cdp.session(id); + if (!session) { + throw new Error(`Unknown CDP session with id ${id}`); + } + if (!this.#adapters.has(session)) { + const adapter = new CDPClientAdapter(session, id, this.#browserCdpConnection); + this.#adapters.set(session, adapter); + return adapter; + } + return this.#adapters.get(session); + } + close() { + this.#browserCdpConnection.close(); + for (const adapter of this.#adapters.values()) { + adapter.close(); + } + } +}; +var CDPClientAdapter = class extends BidiMapper.EventEmitter { + #closed = false; + #client; + sessionId = void 0; + #browserClient; + constructor(client, sessionId, browserClient) { + super(); + this.#client = client; + this.sessionId = sessionId; + this.#browserClient = browserClient; + this.#client.on("*", this.#forwardMessage); + } + browserClient() { + return this.#browserClient; + } + #forwardMessage = (method, event) => { + this.emit(method, event); + }; + async sendCommand(method, ...params) { + if (this.#closed) { + return; + } + try { + return await this.#client.send(method, ...params); + } catch (err) { + if (this.#closed) { + return; + } + throw err; + } + } + close() { + this.#client.off("*", this.#forwardMessage); + this.#closed = true; + } + isCloseError(error) { + return error instanceof TargetCloseError; + } +}; +var NoOpTransport = class extends BidiMapper.EventEmitter { + #onMessage = async (_m) => { + return; + }; + emitMessage(message) { + void this.#onMessage(message); + } + setOnMessage(onMessage) { + this.#onMessage = onMessage; + } + async sendMessage(message) { + this.emit("bidiResponse", message); + } + close() { + this.#onMessage = async (_m) => { + return; + }; + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Browser.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/BrowserContext.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/core/UserContext.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/core/BrowsingContext.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/core/Navigation.js +init_cjs_shim(); +var __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 = 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 Navigation = (() => { + var _a3; + let _classSuper = EventEmitter; + let _instanceExtraInitializers = []; + let _dispose_decorators; + return class Navigation2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + __esDecorate(this, null, _dispose_decorators, { kind: "method", name: "dispose", static: false, private: false, access: { has: (obj) => "dispose" in obj, get: (obj) => obj.dispose }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static from(context) { + const navigation = new Navigation2(context); + navigation.#initialize(); + return navigation; + } + #request = __runInitializers(this, _instanceExtraInitializers); + #navigation; + #browsingContext; + #disposables = new DisposableStack(); + #id; + constructor(context) { + super(); + this.#browsingContext = context; + } + #initialize() { + const browsingContextEmitter = this.#disposables.use(new EventEmitter(this.#browsingContext)); + browsingContextEmitter.once("closed", () => { + this.emit("failed", { + url: this.#browsingContext.url, + timestamp: /* @__PURE__ */ new Date() + }); + this.dispose(); + }); + browsingContextEmitter.on("request", ({ request }) => { + if (request.navigation === void 0 || // If a request with a navigation ID comes in, then the navigation ID is + // for this navigation. + !this.#matches(request.navigation)) { + return; + } + this.#request = request; + this.emit("request", request); + const requestEmitter = this.#disposables.use(new EventEmitter(this.#request)); + requestEmitter.on("redirect", (request2) => { + this.#request = request2; + }); + }); + const sessionEmitter = this.#disposables.use(new EventEmitter(this.#session)); + sessionEmitter.on("browsingContext.navigationStarted", (info) => { + if (info.context !== this.#browsingContext.id || this.#navigation !== void 0) { + return; + } + this.#navigation = Navigation2.from(this.#browsingContext); + }); + for (const eventName of [ + "browsingContext.domContentLoaded", + "browsingContext.load" + ]) { + sessionEmitter.on(eventName, (info) => { + if (info.context !== this.#browsingContext.id || info.navigation === null || !this.#matches(info.navigation)) { + return; + } + this.dispose(); + }); + } + for (const [eventName, event] of [ + ["browsingContext.fragmentNavigated", "fragment"], + ["browsingContext.navigationFailed", "failed"], + ["browsingContext.navigationAborted", "aborted"] + ]) { + sessionEmitter.on(eventName, (info) => { + if (info.context !== this.#browsingContext.id || // Note we don't check if `navigation` is null since `null` means the + // fragment navigated. + !this.#matches(info.navigation)) { + return; + } + this.emit(event, { + url: info.url, + timestamp: new Date(info.timestamp) + }); + this.dispose(); + }); + } + } + #matches(navigation) { + if (this.#navigation !== void 0 && !this.#navigation.disposed) { + return false; + } + if (this.#id === void 0) { + this.#id = navigation; + return true; + } + return this.#id === navigation; + } + get #session() { + return this.#browsingContext.userContext.browser.session; + } + get disposed() { + return this.#disposables.disposed; + } + get request() { + return this.#request; + } + get navigation() { + return this.#navigation; + } + dispose() { + this[disposeSymbol](); + } + [(_dispose_decorators = [inertIfDisposed], disposeSymbol)]() { + this.#disposables.dispose(); + super[disposeSymbol](); + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/core/Realm.js +init_cjs_shim(); +var __runInitializers2 = 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 __esDecorate2 = 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 _a; +var Realm2 = (() => { + let _classSuper = EventEmitter; + let _instanceExtraInitializers = []; + let _dispose_decorators; + let _disown_decorators; + let _callFunction_decorators; + let _evaluate_decorators; + let _resolveExecutionContextId_decorators; + return class Realm extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + __esDecorate2(this, null, _dispose_decorators, { kind: "method", name: "dispose", static: false, private: false, access: { has: (obj) => "dispose" in obj, get: (obj) => obj.dispose }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _disown_decorators, { kind: "method", name: "disown", static: false, private: false, access: { has: (obj) => "disown" in obj, get: (obj) => obj.disown }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _callFunction_decorators, { kind: "method", name: "callFunction", static: false, private: false, access: { has: (obj) => "callFunction" in obj, get: (obj) => obj.callFunction }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _evaluate_decorators, { kind: "method", name: "evaluate", static: false, private: false, access: { has: (obj) => "evaluate" in obj, get: (obj) => obj.evaluate }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _resolveExecutionContextId_decorators, { kind: "method", name: "resolveExecutionContextId", static: false, private: false, access: { has: (obj) => "resolveExecutionContextId" in obj, get: (obj) => obj.resolveExecutionContextId }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + #reason = __runInitializers2(this, _instanceExtraInitializers); + disposables = new DisposableStack(); + id; + origin; + executionContextId; + constructor(id, origin) { + super(); + this.id = id; + this.origin = origin; + } + get disposed() { + return this.#reason !== void 0; + } + get target() { + return { realm: this.id }; + } + dispose(reason) { + this.#reason = reason; + this[disposeSymbol](); + } + async disown(handles) { + await this.session.send("script.disown", { + target: this.target, + handles + }); + } + async callFunction(functionDeclaration, awaitPromise, options = {}) { + const { result } = await this.session.send("script.callFunction", { + functionDeclaration, + awaitPromise, + target: this.target, + ...options + }); + return result; + } + async evaluate(expression, awaitPromise, options = {}) { + const { result } = await this.session.send("script.evaluate", { + expression, + awaitPromise, + target: this.target, + ...options + }); + return result; + } + async resolveExecutionContextId() { + if (!this.executionContextId) { + const { result } = await this.session.connection.send("cdp.resolveRealm", { realm: this.id }); + this.executionContextId = result.executionContextId; + } + return this.executionContextId; + } + [(_dispose_decorators = [inertIfDisposed], _disown_decorators = [throwIfDisposed((realm) => { + return realm.#reason; + })], _callFunction_decorators = [throwIfDisposed((realm) => { + return realm.#reason; + })], _evaluate_decorators = [throwIfDisposed((realm) => { + return realm.#reason; + })], _resolveExecutionContextId_decorators = [throwIfDisposed((realm) => { + return realm.#reason; + })], disposeSymbol)]() { + this.#reason ??= "Realm already destroyed, probably because all associated browsing contexts closed."; + this.emit("destroyed", { reason: this.#reason }); + this.disposables.dispose(); + super[disposeSymbol](); + } + }; +})(); +var WindowRealm = class extends Realm2 { + static from(context, sandbox) { + const realm = new WindowRealm(context, sandbox); + realm.#initialize(); + return realm; + } + browsingContext; + sandbox; + #workers = /* @__PURE__ */ new Map(); + constructor(context, sandbox) { + super("", ""); + this.browsingContext = context; + this.sandbox = sandbox; + } + #initialize() { + const browsingContextEmitter = this.disposables.use(new EventEmitter(this.browsingContext)); + browsingContextEmitter.on("closed", ({ reason }) => { + this.dispose(reason); + }); + const sessionEmitter = this.disposables.use(new EventEmitter(this.session)); + sessionEmitter.on("script.realmCreated", (info) => { + if (info.type !== "window" || info.context !== this.browsingContext.id || info.sandbox !== this.sandbox) { + return; + } + this.id = info.realm; + this.origin = info.origin; + this.executionContextId = void 0; + this.emit("updated", this); + }); + sessionEmitter.on("script.realmCreated", (info) => { + if (info.type !== "dedicated-worker") { + return; + } + if (!info.owners.includes(this.id)) { + return; + } + const realm = DedicatedWorkerRealm.from(this, info.realm, info.origin); + this.#workers.set(realm.id, realm); + const realmEmitter = this.disposables.use(new EventEmitter(realm)); + realmEmitter.once("destroyed", () => { + realmEmitter.removeAllListeners(); + this.#workers.delete(realm.id); + }); + this.emit("worker", realm); + }); + } + get session() { + return this.browsingContext.userContext.browser.session; + } + get target() { + return { context: this.browsingContext.id, sandbox: this.sandbox }; + } +}; +var DedicatedWorkerRealm = class extends Realm2 { + static from(owner, id, origin) { + const realm = new _a(owner, id, origin); + realm.#initialize(); + return realm; + } + #workers = /* @__PURE__ */ new Map(); + owners; + constructor(owner, id, origin) { + super(id, origin); + this.owners = /* @__PURE__ */ new Set([owner]); + } + #initialize() { + const sessionEmitter = this.disposables.use(new EventEmitter(this.session)); + sessionEmitter.on("script.realmDestroyed", (info) => { + if (info.realm !== this.id) { + return; + } + this.dispose("Realm already destroyed."); + }); + sessionEmitter.on("script.realmCreated", (info) => { + if (info.type !== "dedicated-worker") { + return; + } + if (!info.owners.includes(this.id)) { + return; + } + const realm = _a.from(this, info.realm, info.origin); + this.#workers.set(realm.id, realm); + const realmEmitter = this.disposables.use(new EventEmitter(realm)); + realmEmitter.once("destroyed", () => { + this.#workers.delete(realm.id); + }); + this.emit("worker", realm); + }); + } + get session() { + return this.owners.values().next().value.session; + } +}; +_a = DedicatedWorkerRealm; +var SharedWorkerRealm = class extends Realm2 { + static from(browser, id, origin) { + const realm = new SharedWorkerRealm(browser, id, origin); + realm.#initialize(); + return realm; + } + #workers = /* @__PURE__ */ new Map(); + browser; + constructor(browser, id, origin) { + super(id, origin); + this.browser = browser; + } + #initialize() { + const sessionEmitter = this.disposables.use(new EventEmitter(this.session)); + sessionEmitter.on("script.realmDestroyed", (info) => { + if (info.realm !== this.id) { + return; + } + this.dispose("Realm already destroyed."); + }); + sessionEmitter.on("script.realmCreated", (info) => { + if (info.type !== "dedicated-worker") { + return; + } + if (!info.owners.includes(this.id)) { + return; + } + const realm = DedicatedWorkerRealm.from(this, info.realm, info.origin); + this.#workers.set(realm.id, realm); + const realmEmitter = this.disposables.use(new EventEmitter(realm)); + realmEmitter.once("destroyed", () => { + this.#workers.delete(realm.id); + }); + this.emit("worker", realm); + }); + } + get session() { + return this.browser.session; + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/core/Request.js +init_cjs_shim(); +var __runInitializers3 = 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 __esDecorate3 = 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 Request = (() => { + var _a3; + let _classSuper = EventEmitter; + let _instanceExtraInitializers = []; + let _dispose_decorators; + return class Request2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + __esDecorate3(this, null, _dispose_decorators, { kind: "method", name: "dispose", static: false, private: false, access: { has: (obj) => "dispose" in obj, get: (obj) => obj.dispose }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static from(browsingContext, event) { + const request = new Request2(browsingContext, event); + request.#initialize(); + return request; + } + #error = __runInitializers3(this, _instanceExtraInitializers); + #redirect; + #response; + #browsingContext; + #disposables = new DisposableStack(); + #event; + constructor(browsingContext, event) { + super(); + this.#browsingContext = browsingContext; + this.#event = event; + } + #initialize() { + const browsingContextEmitter = this.#disposables.use(new EventEmitter(this.#browsingContext)); + browsingContextEmitter.once("closed", ({ reason }) => { + this.#error = reason; + this.emit("error", this.#error); + this.dispose(); + }); + const sessionEmitter = this.#disposables.use(new EventEmitter(this.#session)); + sessionEmitter.on("network.beforeRequestSent", (event) => { + if (event.context !== this.#browsingContext.id || event.request.request !== this.id || event.redirectCount !== this.#event.redirectCount + 1) { + return; + } + this.#redirect = Request2.from(this.#browsingContext, event); + this.emit("redirect", this.#redirect); + this.dispose(); + }); + sessionEmitter.on("network.authRequired", (event) => { + if (event.context !== this.#browsingContext.id || event.request.request !== this.id || // Don't try to authenticate for events that are not blocked + !event.isBlocked) { + return; + } + this.emit("authenticate", void 0); + }); + sessionEmitter.on("network.fetchError", (event) => { + if (event.context !== this.#browsingContext.id || event.request.request !== this.id || this.#event.redirectCount !== event.redirectCount) { + return; + } + this.#error = event.errorText; + this.emit("error", this.#error); + this.dispose(); + }); + sessionEmitter.on("network.responseCompleted", (event) => { + if (event.context !== this.#browsingContext.id || event.request.request !== this.id || this.#event.redirectCount !== event.redirectCount) { + return; + } + this.#response = event.response; + this.#event.request.timings = event.request.timings; + this.emit("success", this.#response); + if (this.#response.status >= 300 && this.#response.status < 400) { + return; + } + this.dispose(); + }); + } + get #session() { + return this.#browsingContext.userContext.browser.session; + } + get disposed() { + return this.#disposables.disposed; + } + get error() { + return this.#error; + } + get headers() { + return this.#event.request.headers; + } + get id() { + return this.#event.request.request; + } + get initiator() { + return this.#event.initiator; + } + get method() { + return this.#event.request.method; + } + get navigation() { + return this.#event.navigation ?? void 0; + } + get redirect() { + return this.#redirect; + } + get lastRedirect() { + let redirect = this.#redirect; + while (redirect) { + if (redirect && !redirect.#redirect) { + return redirect; + } + redirect = redirect.#redirect; + } + return redirect; + } + get response() { + return this.#response; + } + get url() { + return this.#event.request.url; + } + get isBlocked() { + return this.#event.isBlocked; + } + get resourceType() { + return this.#event.request["goog:resourceType"] ?? void 0; + } + get postData() { + return this.#event.request["goog:postData"] ?? void 0; + } + get hasPostData() { + return this.#event.request["goog:hasPostData"] ?? false; + } + async continueRequest({ url, method, headers, cookies, body }) { + await this.#session.send("network.continueRequest", { + request: this.id, + url, + method, + headers, + body, + cookies + }); + } + async failRequest() { + await this.#session.send("network.failRequest", { + request: this.id + }); + } + async provideResponse({ statusCode, reasonPhrase, headers, body }) { + await this.#session.send("network.provideResponse", { + request: this.id, + statusCode, + reasonPhrase, + headers, + body + }); + } + async continueWithAuth(parameters) { + if (parameters.action === "provideCredentials") { + await this.#session.send("network.continueWithAuth", { + request: this.id, + action: parameters.action, + credentials: parameters.credentials + }); + } else { + await this.#session.send("network.continueWithAuth", { + request: this.id, + action: parameters.action + }); + } + } + dispose() { + this[disposeSymbol](); + } + [(_dispose_decorators = [inertIfDisposed], disposeSymbol)]() { + this.#disposables.dispose(); + super[disposeSymbol](); + } + timing() { + return this.#event.request.timings; + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/core/UserPrompt.js +init_cjs_shim(); +var __runInitializers4 = 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 __esDecorate4 = 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 UserPrompt = (() => { + let _classSuper = EventEmitter; + let _instanceExtraInitializers = []; + let _dispose_decorators; + let _handle_decorators; + return class UserPrompt2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + __esDecorate4(this, null, _dispose_decorators, { kind: "method", name: "dispose", static: false, private: false, access: { has: (obj) => "dispose" in obj, get: (obj) => obj.dispose }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate4(this, null, _handle_decorators, { kind: "method", name: "handle", static: false, private: false, access: { has: (obj) => "handle" in obj, get: (obj) => obj.handle }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static from(browsingContext, info) { + const userPrompt = new UserPrompt2(browsingContext, info); + userPrompt.#initialize(); + return userPrompt; + } + #reason = __runInitializers4(this, _instanceExtraInitializers); + #result; + #disposables = new DisposableStack(); + browsingContext; + info; + constructor(context, info) { + super(); + this.browsingContext = context; + this.info = info; + } + #initialize() { + const browserContextEmitter = this.#disposables.use(new EventEmitter(this.browsingContext)); + browserContextEmitter.once("closed", ({ reason }) => { + this.dispose(`User prompt already closed: ${reason}`); + }); + const sessionEmitter = this.#disposables.use(new EventEmitter(this.#session)); + sessionEmitter.on("browsingContext.userPromptClosed", (parameters) => { + if (parameters.context !== this.browsingContext.id) { + return; + } + this.#result = parameters; + this.emit("handled", parameters); + this.dispose("User prompt already handled."); + }); + } + get #session() { + return this.browsingContext.userContext.browser.session; + } + get closed() { + return this.#reason !== void 0; + } + get disposed() { + return this.closed; + } + get handled() { + if (this.info.handler === "accept" || this.info.handler === "dismiss") { + return true; + } + return this.#result !== void 0; + } + get result() { + return this.#result; + } + dispose(reason) { + this.#reason = reason; + this[disposeSymbol](); + } + async handle(options = {}) { + await this.#session.send("browsingContext.handleUserPrompt", { + ...options, + context: this.info.context + }); + return this.#result; + } + [(_dispose_decorators = [inertIfDisposed], _handle_decorators = [throwIfDisposed((prompt) => { + return prompt.#reason; + })], disposeSymbol)]() { + this.#reason ??= "User prompt already closed, probably because the associated browsing context was destroyed."; + this.emit("closed", { reason: this.#reason }); + this.#disposables.dispose(); + super[disposeSymbol](); + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/core/BrowsingContext.js +var __runInitializers5 = 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 __esDecorate5 = 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 BrowsingContext = (() => { + var _a3; + let _classSuper = EventEmitter; + let _instanceExtraInitializers = []; + let _dispose_decorators; + let _activate_decorators; + let _captureScreenshot_decorators; + let _close_decorators; + let _traverseHistory_decorators; + let _navigate_decorators; + let _reload_decorators; + let _setCacheBehavior_decorators; + let _print_decorators; + let _handleUserPrompt_decorators; + let _setViewport_decorators; + let _performActions_decorators; + let _releaseActions_decorators; + let _createWindowRealm_decorators; + let _addPreloadScript_decorators; + let _addIntercept_decorators; + let _removePreloadScript_decorators; + let _getCookies_decorators; + let _setCookie_decorators; + let _setFiles_decorators; + let _subscribe_decorators; + let _addInterception_decorators; + let _deleteCookie_decorators; + let _locateNodes_decorators; + return class BrowsingContext2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + _deleteCookie_decorators = [throwIfDisposed((context) => { + return context.#reason; + })]; + _locateNodes_decorators = [throwIfDisposed((context) => { + return context.#reason; + })]; + __esDecorate5(this, null, _dispose_decorators, { kind: "method", name: "dispose", static: false, private: false, access: { has: (obj) => "dispose" in obj, get: (obj) => obj.dispose }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _activate_decorators, { kind: "method", name: "activate", static: false, private: false, access: { has: (obj) => "activate" in obj, get: (obj) => obj.activate }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _captureScreenshot_decorators, { kind: "method", name: "captureScreenshot", static: false, private: false, access: { has: (obj) => "captureScreenshot" in obj, get: (obj) => obj.captureScreenshot }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _close_decorators, { kind: "method", name: "close", static: false, private: false, access: { has: (obj) => "close" in obj, get: (obj) => obj.close }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _traverseHistory_decorators, { kind: "method", name: "traverseHistory", static: false, private: false, access: { has: (obj) => "traverseHistory" in obj, get: (obj) => obj.traverseHistory }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _navigate_decorators, { kind: "method", name: "navigate", static: false, private: false, access: { has: (obj) => "navigate" in obj, get: (obj) => obj.navigate }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _reload_decorators, { kind: "method", name: "reload", static: false, private: false, access: { has: (obj) => "reload" in obj, get: (obj) => obj.reload }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _setCacheBehavior_decorators, { kind: "method", name: "setCacheBehavior", static: false, private: false, access: { has: (obj) => "setCacheBehavior" in obj, get: (obj) => obj.setCacheBehavior }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _print_decorators, { kind: "method", name: "print", static: false, private: false, access: { has: (obj) => "print" in obj, get: (obj) => obj.print }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _handleUserPrompt_decorators, { kind: "method", name: "handleUserPrompt", static: false, private: false, access: { has: (obj) => "handleUserPrompt" in obj, get: (obj) => obj.handleUserPrompt }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _setViewport_decorators, { kind: "method", name: "setViewport", static: false, private: false, access: { has: (obj) => "setViewport" in obj, get: (obj) => obj.setViewport }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _performActions_decorators, { kind: "method", name: "performActions", static: false, private: false, access: { has: (obj) => "performActions" in obj, get: (obj) => obj.performActions }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _releaseActions_decorators, { kind: "method", name: "releaseActions", static: false, private: false, access: { has: (obj) => "releaseActions" in obj, get: (obj) => obj.releaseActions }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _createWindowRealm_decorators, { kind: "method", name: "createWindowRealm", static: false, private: false, access: { has: (obj) => "createWindowRealm" in obj, get: (obj) => obj.createWindowRealm }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _addPreloadScript_decorators, { kind: "method", name: "addPreloadScript", static: false, private: false, access: { has: (obj) => "addPreloadScript" in obj, get: (obj) => obj.addPreloadScript }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _addIntercept_decorators, { kind: "method", name: "addIntercept", static: false, private: false, access: { has: (obj) => "addIntercept" in obj, get: (obj) => obj.addIntercept }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _removePreloadScript_decorators, { kind: "method", name: "removePreloadScript", static: false, private: false, access: { has: (obj) => "removePreloadScript" in obj, get: (obj) => obj.removePreloadScript }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _getCookies_decorators, { kind: "method", name: "getCookies", static: false, private: false, access: { has: (obj) => "getCookies" in obj, get: (obj) => obj.getCookies }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _setCookie_decorators, { kind: "method", name: "setCookie", static: false, private: false, access: { has: (obj) => "setCookie" in obj, get: (obj) => obj.setCookie }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _setFiles_decorators, { kind: "method", name: "setFiles", static: false, private: false, access: { has: (obj) => "setFiles" in obj, get: (obj) => obj.setFiles }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _subscribe_decorators, { kind: "method", name: "subscribe", static: false, private: false, access: { has: (obj) => "subscribe" in obj, get: (obj) => obj.subscribe }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _addInterception_decorators, { kind: "method", name: "addInterception", static: false, private: false, access: { has: (obj) => "addInterception" in obj, get: (obj) => obj.addInterception }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _deleteCookie_decorators, { kind: "method", name: "deleteCookie", static: false, private: false, access: { has: (obj) => "deleteCookie" in obj, get: (obj) => obj.deleteCookie }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate5(this, null, _locateNodes_decorators, { kind: "method", name: "locateNodes", static: false, private: false, access: { has: (obj) => "locateNodes" in obj, get: (obj) => obj.locateNodes }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static from(userContext, parent, id, url, originalOpener) { + const browsingContext = new BrowsingContext2(userContext, parent, id, url, originalOpener); + browsingContext.#initialize(); + return browsingContext; + } + #navigation = __runInitializers5(this, _instanceExtraInitializers); + #reason; + #url; + #children = /* @__PURE__ */ new Map(); + #disposables = new DisposableStack(); + #realms = /* @__PURE__ */ new Map(); + #requests = /* @__PURE__ */ new Map(); + defaultRealm; + id; + parent; + userContext; + originalOpener; + constructor(context, parent, id, url, originalOpener) { + super(); + this.#url = url; + this.id = id; + this.parent = parent; + this.userContext = context; + this.originalOpener = originalOpener; + this.defaultRealm = this.#createWindowRealm(); + } + #initialize() { + const userContextEmitter = this.#disposables.use(new EventEmitter(this.userContext)); + userContextEmitter.once("closed", ({ reason }) => { + this.dispose(`Browsing context already closed: ${reason}`); + }); + const sessionEmitter = this.#disposables.use(new EventEmitter(this.#session)); + sessionEmitter.on("browsingContext.contextCreated", (info) => { + if (info.parent !== this.id) { + return; + } + const browsingContext = BrowsingContext2.from(this.userContext, this, info.context, info.url, info.originalOpener); + this.#children.set(info.context, browsingContext); + const browsingContextEmitter = this.#disposables.use(new EventEmitter(browsingContext)); + browsingContextEmitter.once("closed", () => { + browsingContextEmitter.removeAllListeners(); + this.#children.delete(browsingContext.id); + }); + this.emit("browsingcontext", { browsingContext }); + }); + sessionEmitter.on("browsingContext.contextDestroyed", (info) => { + if (info.context !== this.id) { + return; + } + this.dispose("Browsing context already closed."); + }); + sessionEmitter.on("browsingContext.domContentLoaded", (info) => { + if (info.context !== this.id) { + return; + } + this.#url = info.url; + this.emit("DOMContentLoaded", void 0); + }); + sessionEmitter.on("browsingContext.load", (info) => { + if (info.context !== this.id) { + return; + } + this.#url = info.url; + this.emit("load", void 0); + }); + sessionEmitter.on("browsingContext.navigationStarted", (info) => { + if (info.context !== this.id) { + return; + } + for (const [id, request] of this.#requests) { + if (request.disposed) { + this.#requests.delete(id); + } + } + if (this.#navigation !== void 0 && !this.#navigation.disposed) { + return; + } + this.#navigation = Navigation.from(this); + const navigationEmitter = this.#disposables.use(new EventEmitter(this.#navigation)); + for (const eventName of ["fragment", "failed", "aborted"]) { + navigationEmitter.once(eventName, ({ url }) => { + navigationEmitter[disposeSymbol](); + this.#url = url; + }); + } + this.emit("navigation", { navigation: this.#navigation }); + }); + sessionEmitter.on("network.beforeRequestSent", (event) => { + if (event.context !== this.id) { + return; + } + if (this.#requests.has(event.request.request)) { + return; + } + const request = Request.from(this, event); + this.#requests.set(request.id, request); + this.emit("request", { request }); + }); + sessionEmitter.on("log.entryAdded", (entry) => { + if (entry.source.context !== this.id) { + return; + } + this.emit("log", { entry }); + }); + sessionEmitter.on("browsingContext.userPromptOpened", (info) => { + if (info.context !== this.id) { + return; + } + const userPrompt = UserPrompt.from(this, info); + this.emit("userprompt", { userPrompt }); + }); + } + get #session() { + return this.userContext.browser.session; + } + get children() { + return this.#children.values(); + } + get closed() { + return this.#reason !== void 0; + } + get disposed() { + return this.closed; + } + get realms() { + const self = this; + return function* () { + yield self.defaultRealm; + yield* self.#realms.values(); + }(); + } + get top() { + let context = this; + for (let { parent } = context; parent; { parent } = context) { + context = parent; + } + return context; + } + get url() { + return this.#url; + } + #createWindowRealm(sandbox) { + const realm = WindowRealm.from(this, sandbox); + realm.on("worker", (realm2) => { + this.emit("worker", { realm: realm2 }); + }); + return realm; + } + dispose(reason) { + this.#reason = reason; + for (const context of this.#children.values()) { + context.dispose("Parent browsing context was disposed"); + } + this[disposeSymbol](); + } + async activate() { + await this.#session.send("browsingContext.activate", { + context: this.id + }); + } + async captureScreenshot(options = {}) { + const { result: { data } } = await this.#session.send("browsingContext.captureScreenshot", { + context: this.id, + ...options + }); + return data; + } + async close(promptUnload) { + await Promise.all([...this.#children.values()].map(async (child) => { + await child.close(promptUnload); + })); + await this.#session.send("browsingContext.close", { + context: this.id, + promptUnload + }); + } + async traverseHistory(delta) { + await this.#session.send("browsingContext.traverseHistory", { + context: this.id, + delta + }); + } + async navigate(url, wait) { + await this.#session.send("browsingContext.navigate", { + context: this.id, + url, + wait + }); + } + async reload(options = {}) { + await this.#session.send("browsingContext.reload", { + context: this.id, + ...options + }); + } + async setCacheBehavior(cacheBehavior) { + await this.#session.send("network.setCacheBehavior", { + contexts: [this.id], + cacheBehavior + }); + } + async print(options = {}) { + const { result: { data } } = await this.#session.send("browsingContext.print", { + context: this.id, + ...options + }); + return data; + } + async handleUserPrompt(options = {}) { + await this.#session.send("browsingContext.handleUserPrompt", { + context: this.id, + ...options + }); + } + async setViewport(options = {}) { + await this.#session.send("browsingContext.setViewport", { + context: this.id, + ...options + }); + } + async performActions(actions) { + await this.#session.send("input.performActions", { + context: this.id, + actions + }); + } + async releaseActions() { + await this.#session.send("input.releaseActions", { + context: this.id + }); + } + createWindowRealm(sandbox) { + return this.#createWindowRealm(sandbox); + } + async addPreloadScript(functionDeclaration, options = {}) { + return await this.userContext.browser.addPreloadScript(functionDeclaration, { + ...options, + contexts: [this] + }); + } + async addIntercept(options) { + const { result: { intercept } } = await this.userContext.browser.session.send("network.addIntercept", { + ...options, + contexts: [this.id] + }); + return intercept; + } + async removePreloadScript(script) { + await this.userContext.browser.removePreloadScript(script); + } + async getCookies(options = {}) { + const { result: { cookies } } = await this.#session.send("storage.getCookies", { + ...options, + partition: { + type: "context", + context: this.id + } + }); + return cookies; + } + async setCookie(cookie) { + await this.#session.send("storage.setCookie", { + cookie, + partition: { + type: "context", + context: this.id + } + }); + } + async setFiles(element, files) { + await this.#session.send("input.setFiles", { + context: this.id, + element, + files + }); + } + async subscribe(events) { + await this.#session.subscribe(events, [this.id]); + } + async addInterception(events) { + await this.#session.subscribe(events, [this.id]); + } + [(_dispose_decorators = [inertIfDisposed], _activate_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _captureScreenshot_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _close_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _traverseHistory_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _navigate_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _reload_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _setCacheBehavior_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _print_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _handleUserPrompt_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _setViewport_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _performActions_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _releaseActions_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _createWindowRealm_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _addPreloadScript_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _addIntercept_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _removePreloadScript_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _getCookies_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _setCookie_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _setFiles_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _subscribe_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _addInterception_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], disposeSymbol)]() { + this.#reason ??= "Browsing context already closed, probably because the user context closed."; + this.emit("closed", { reason: this.#reason }); + this.#disposables.dispose(); + super[disposeSymbol](); + } + async deleteCookie(...cookieFilters) { + await Promise.all(cookieFilters.map(async (filter2) => { + await this.#session.send("storage.deleteCookies", { + filter: filter2, + partition: { + type: "context", + context: this.id + } + }); + })); + } + async locateNodes(locator, startNodes) { + const result = await this.#session.send("browsingContext.locateNodes", { + context: this.id, + locator, + startNodes: startNodes.length ? startNodes : void 0 + }); + return result.result.nodes; + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/core/UserContext.js +var __runInitializers6 = 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 __esDecorate6 = 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 UserContext = (() => { + let _classSuper = EventEmitter; + let _instanceExtraInitializers = []; + let _dispose_decorators; + let _createBrowsingContext_decorators; + let _remove_decorators; + let _getCookies_decorators; + let _setCookie_decorators; + let _setPermissions_decorators; + return class UserContext2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + __esDecorate6(this, null, _dispose_decorators, { kind: "method", name: "dispose", static: false, private: false, access: { has: (obj) => "dispose" in obj, get: (obj) => obj.dispose }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate6(this, null, _createBrowsingContext_decorators, { kind: "method", name: "createBrowsingContext", static: false, private: false, access: { has: (obj) => "createBrowsingContext" in obj, get: (obj) => obj.createBrowsingContext }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate6(this, null, _remove_decorators, { kind: "method", name: "remove", static: false, private: false, access: { has: (obj) => "remove" in obj, get: (obj) => obj.remove }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate6(this, null, _getCookies_decorators, { kind: "method", name: "getCookies", static: false, private: false, access: { has: (obj) => "getCookies" in obj, get: (obj) => obj.getCookies }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate6(this, null, _setCookie_decorators, { kind: "method", name: "setCookie", static: false, private: false, access: { has: (obj) => "setCookie" in obj, get: (obj) => obj.setCookie }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate6(this, null, _setPermissions_decorators, { kind: "method", name: "setPermissions", static: false, private: false, access: { has: (obj) => "setPermissions" in obj, get: (obj) => obj.setPermissions }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static DEFAULT = "default"; + static create(browser, id) { + const context = new UserContext2(browser, id); + context.#initialize(); + return context; + } + #reason = __runInitializers6(this, _instanceExtraInitializers); + // Note these are only top-level contexts. + #browsingContexts = /* @__PURE__ */ new Map(); + #disposables = new DisposableStack(); + #id; + browser; + constructor(browser, id) { + super(); + this.#id = id; + this.browser = browser; + } + #initialize() { + const browserEmitter = this.#disposables.use(new EventEmitter(this.browser)); + browserEmitter.once("closed", ({ reason }) => { + this.dispose(`User context was closed: ${reason}`); + }); + browserEmitter.once("disconnected", ({ reason }) => { + this.dispose(`User context was closed: ${reason}`); + }); + const sessionEmitter = this.#disposables.use(new EventEmitter(this.#session)); + sessionEmitter.on("browsingContext.contextCreated", (info) => { + if (info.parent) { + return; + } + if (info.userContext !== this.#id) { + return; + } + const browsingContext = BrowsingContext.from(this, void 0, info.context, info.url, info.originalOpener); + this.#browsingContexts.set(browsingContext.id, browsingContext); + const browsingContextEmitter = this.#disposables.use(new EventEmitter(browsingContext)); + browsingContextEmitter.on("closed", () => { + browsingContextEmitter.removeAllListeners(); + this.#browsingContexts.delete(browsingContext.id); + }); + this.emit("browsingcontext", { browsingContext }); + }); + } + get #session() { + return this.browser.session; + } + get browsingContexts() { + return this.#browsingContexts.values(); + } + get closed() { + return this.#reason !== void 0; + } + get disposed() { + return this.closed; + } + get id() { + return this.#id; + } + dispose(reason) { + this.#reason = reason; + this[disposeSymbol](); + } + async createBrowsingContext(type, options = {}) { + const { result: { context: contextId } } = await this.#session.send("browsingContext.create", { + type, + ...options, + referenceContext: options.referenceContext?.id, + userContext: this.#id + }); + const browsingContext = this.#browsingContexts.get(contextId); + assert(browsingContext, "The WebDriver BiDi implementation is failing to create a browsing context correctly."); + return browsingContext; + } + async remove() { + try { + await this.#session.send("browser.removeUserContext", { + userContext: this.#id + }); + } finally { + this.dispose("User context already closed."); + } + } + async getCookies(options = {}, sourceOrigin = void 0) { + const { result: { cookies } } = await this.#session.send("storage.getCookies", { + ...options, + partition: { + type: "storageKey", + userContext: this.#id, + sourceOrigin + } + }); + return cookies; + } + async setCookie(cookie, sourceOrigin) { + await this.#session.send("storage.setCookie", { + cookie, + partition: { + type: "storageKey", + sourceOrigin, + userContext: this.id + } + }); + } + async setPermissions(origin, descriptor, state) { + await this.#session.send("permissions.setPermission", { + origin, + descriptor, + state, + userContext: this.#id + }); + } + [(_dispose_decorators = [inertIfDisposed], _createBrowsingContext_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _remove_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _getCookies_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _setCookie_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], _setPermissions_decorators = [throwIfDisposed((context) => { + return context.#reason; + })], disposeSymbol)]() { + this.#reason ??= "User context already closed, probably because the browser disconnected/closed."; + this.emit("closed", { reason: this.#reason }); + this.#disposables.dispose(); + super[disposeSymbol](); + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Page.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Frame.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Deserializer.js +init_cjs_shim(); +var _deserializeNumber, deserializeNumber_fn, _deserializeTuple, deserializeTuple_fn; +var BidiDeserializer = class { + static deserialize(result) { + if (!result) { + debugError("Service did not produce a result."); + return void 0; + } + switch (result.type) { + case "array": + return result.value?.map((value) => { + return this.deserialize(value); + }); + case "set": + return result.value?.reduce((acc, value) => { + return acc.add(this.deserialize(value)); + }, /* @__PURE__ */ new Set()); + case "object": + return result.value?.reduce((acc, tuple) => { + const { key, value } = __privateMethod(this, _deserializeTuple, deserializeTuple_fn).call(this, tuple); + acc[key] = value; + return acc; + }, {}); + case "map": + return result.value?.reduce((acc, tuple) => { + const { key, value } = __privateMethod(this, _deserializeTuple, deserializeTuple_fn).call(this, tuple); + return acc.set(key, value); + }, /* @__PURE__ */ new Map()); + case "promise": + return {}; + case "regexp": + return new RegExp(result.value.pattern, result.value.flags); + case "date": + return new Date(result.value); + case "undefined": + return void 0; + case "null": + return null; + case "number": + return __privateMethod(this, _deserializeNumber, deserializeNumber_fn).call(this, result.value); + case "bigint": + return BigInt(result.value); + case "boolean": + return Boolean(result.value); + case "string": + return result.value; + } + debugError(`Deserialization of type ${result.type} not supported.`); + return void 0; + } +}; +_deserializeNumber = new WeakSet(); +deserializeNumber_fn = function(value) { + switch (value) { + case "-0": + return -0; + case "NaN": + return NaN; + case "Infinity": + return Infinity; + case "-Infinity": + return -Infinity; + default: + return value; + } +}; +_deserializeTuple = new WeakSet(); +deserializeTuple_fn = function([serializedKey, serializedValue]) { + const key = typeof serializedKey === "string" ? serializedKey : this.deserialize(serializedKey); + const value = this.deserialize(serializedValue); + return { key, value }; +}; +__privateAdd(BidiDeserializer, _deserializeNumber); +__privateAdd(BidiDeserializer, _deserializeTuple); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Dialog.js +init_cjs_shim(); +var BidiDialog = class extends Dialog { + static from(prompt) { + return new BidiDialog(prompt); + } + #prompt; + constructor(prompt) { + super(prompt.info.type, prompt.info.message, prompt.info.defaultValue); + this.#prompt = prompt; + this.handled = prompt.handled; + } + async handle(options) { + await this.#prompt.handle({ + accept: options.accept, + userText: options.text + }); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/ExposedFunction.js +init_cjs_shim(); +var Bidi = __toESM(require_protocol(), 1); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/ElementHandle.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/JSHandle.js +init_cjs_shim(); +var BidiJSHandle = class extends JSHandle { + static from(value, realm) { + return new BidiJSHandle(value, realm); + } + #remoteValue; + realm; + #disposed = false; + constructor(value, realm) { + super(); + this.#remoteValue = value; + this.realm = realm; + } + get disposed() { + return this.#disposed; + } + async jsonValue() { + return await this.evaluate((value) => { + return value; + }); + } + asElement() { + return null; + } + async dispose() { + if (this.#disposed) { + return; + } + this.#disposed = true; + await this.realm.destroyHandles([this]); + } + get isPrimitiveValue() { + switch (this.#remoteValue.type) { + case "string": + case "number": + case "bigint": + case "boolean": + case "undefined": + case "null": + return true; + default: + return false; + } + } + toString() { + if (this.isPrimitiveValue) { + return "JSHandle:" + BidiDeserializer.deserialize(this.#remoteValue); + } + return "JSHandle@" + this.#remoteValue.type; + } + get id() { + return "handle" in this.#remoteValue ? this.#remoteValue.handle : void 0; + } + remoteValue() { + return this.#remoteValue; + } + remoteObject() { + throw new UnsupportedOperation("Not available in WebDriver BiDi"); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/ElementHandle.js +var __runInitializers7 = 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 __esDecorate7 = 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 __addDisposableResource = function(env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env.stack.push({ value, dispose, async }); + } else if (async) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources = function(SuppressedError2) { + return function(env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) + throw env.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var BidiElementHandle = (() => { + let _classSuper = ElementHandle; + let _instanceExtraInitializers = []; + let _autofill_decorators; + let _contentFrame_decorators; + return class BidiElementHandle2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + _autofill_decorators = [throwIfDisposed()]; + _contentFrame_decorators = [throwIfDisposed(), bindIsolatedHandle]; + __esDecorate7(this, null, _autofill_decorators, { kind: "method", name: "autofill", static: false, private: false, access: { has: (obj) => "autofill" in obj, get: (obj) => obj.autofill }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate7(this, null, _contentFrame_decorators, { kind: "method", name: "contentFrame", static: false, private: false, access: { has: (obj) => "contentFrame" in obj, get: (obj) => obj.contentFrame }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static from(value, realm) { + return new BidiElementHandle2(value, realm); + } + constructor(value, realm) { + super(BidiJSHandle.from(value, realm)); + __runInitializers7(this, _instanceExtraInitializers); + } + get realm() { + return this.handle.realm; + } + get frame() { + return this.realm.environment; + } + remoteValue() { + return this.handle.remoteValue(); + } + async autofill(data) { + const client = this.frame.client; + const nodeInfo = await client.send("DOM.describeNode", { + objectId: this.handle.id + }); + const fieldId = nodeInfo.node.backendNodeId; + const frameId = this.frame._id; + await client.send("Autofill.trigger", { + fieldId, + frameId, + card: data.creditCard + }); + } + async contentFrame() { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const handle = __addDisposableResource(env_1, await this.evaluateHandle((element) => { + if (element instanceof HTMLIFrameElement || element instanceof HTMLFrameElement) { + return element.contentWindow; + } + return; + }), false); + const value = handle.remoteValue(); + if (value.type === "window") { + return this.frame.page().frames().find((frame) => { + return frame._id === value.value.context; + }) ?? null; + } + return null; + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources(env_1); + } + } + async uploadFile(...files) { + const path = environment.value.path; + if (path) { + files = files.map((file) => { + if (path.win32.isAbsolute(file) || path.posix.isAbsolute(file)) { + return file; + } else { + return path.resolve(file); + } + }); + } + await this.frame.setFiles(this, files); + } + async *queryAXTree(name, role) { + const results = await this.frame.locateNodes(this, { + type: "accessibility", + value: { + role, + name + } + }); + return yield* AsyncIterableUtil.map(results, (node) => { + return Promise.resolve(BidiElementHandle2.from(node, this.realm)); + }); + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/ExposedFunction.js +var __addDisposableResource2 = function(env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env.stack.push({ value, dispose, async }); + } else if (async) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources2 = function(SuppressedError2) { + return function(env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) + throw env.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var ExposeableFunction = class { + static async from(frame, name, apply, isolate = false) { + const func = new ExposeableFunction(frame, name, apply, isolate); + await func.#initialize(); + return func; + } + #frame; + name; + #apply; + #isolate; + #channel; + #scripts = []; + #disposables = new DisposableStack(); + constructor(frame, name, apply, isolate = false) { + this.#frame = frame; + this.name = name; + this.#apply = apply; + this.#isolate = isolate; + this.#channel = `__puppeteer__${this.#frame._id}_page_exposeFunction_${this.name}`; + } + async #initialize() { + const connection = this.#connection; + const channel = { + type: "channel", + value: { + channel: this.#channel, + ownership: "root" + } + }; + const connectionEmitter = this.#disposables.use(new EventEmitter(connection)); + connectionEmitter.on(Bidi.ChromiumBidi.Script.EventNames.Message, this.#handleMessage); + const functionDeclaration = stringifyFunction(interpolateFunction((callback) => { + Object.assign(globalThis, { + [PLACEHOLDER("name")]: function(...args) { + return new Promise((resolve, reject) => { + callback([resolve, reject, args]); + }); + } + }); + }, { name: JSON.stringify(this.name) })); + const frames = [this.#frame]; + for (const frame of frames) { + frames.push(...frame.childFrames()); + } + await Promise.all(frames.map(async (frame) => { + const realm = this.#isolate ? frame.isolatedRealm() : frame.mainRealm(); + try { + const [script] = await Promise.all([ + frame.browsingContext.addPreloadScript(functionDeclaration, { + arguments: [channel], + sandbox: realm.sandbox + }), + realm.realm.callFunction(functionDeclaration, false, { + arguments: [channel] + }) + ]); + this.#scripts.push([frame, script]); + } catch (error) { + debugError(error); + } + })); + } + get #connection() { + return this.#frame.page().browser().connection; + } + #handleMessage = async (params) => { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + if (params.channel !== this.#channel) { + return; + } + const realm = this.#getRealm(params.source); + if (!realm) { + return; + } + const dataHandle = __addDisposableResource2(env_1, BidiJSHandle.from(params.data, realm), false); + const argsHandle = __addDisposableResource2(env_1, await dataHandle.evaluateHandle(([, , args2]) => { + return args2; + }), false); + const stack = __addDisposableResource2(env_1, new DisposableStack(), false); + const args = []; + for (const [index, handle] of await argsHandle.getProperties()) { + stack.use(handle); + if (handle instanceof BidiElementHandle) { + args[+index] = handle; + stack.use(handle); + continue; + } + args[+index] = handle.jsonValue(); + } + let result; + try { + result = await this.#apply(...await Promise.all(args)); + } catch (error) { + try { + if (error instanceof Error) { + await dataHandle.evaluate(([, reject], name, message, stack2) => { + const error2 = new Error(message); + error2.name = name; + if (stack2) { + error2.stack = stack2; + } + reject(error2); + }, error.name, error.message, error.stack); + } else { + await dataHandle.evaluate(([, reject], error2) => { + reject(error2); + }, error); + } + } catch (error2) { + debugError(error2); + } + return; + } + try { + await dataHandle.evaluate(([resolve], result2) => { + resolve(result2); + }, result); + } catch (error) { + debugError(error); + } + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources2(env_1); + } + }; + #getRealm(source) { + const frame = this.#findFrame(source.context); + if (!frame) { + return; + } + return frame.realm(source.realm); + } + #findFrame(id) { + const frames = [this.#frame]; + for (const frame of frames) { + if (frame._id === id) { + return frame; + } + frames.push(...frame.childFrames()); + } + return; + } + [Symbol.dispose]() { + void this[Symbol.asyncDispose]().catch(debugError); + } + async [Symbol.asyncDispose]() { + this.#disposables.dispose(); + await Promise.all(this.#scripts.map(async ([frame, script]) => { + const realm = this.#isolate ? frame.isolatedRealm() : frame.mainRealm(); + try { + await Promise.all([ + realm.evaluate((name) => { + delete globalThis[name]; + }, this.name), + ...frame.childFrames().map((childFrame) => { + return childFrame.evaluate((name) => { + delete globalThis[name]; + }, this.name); + }), + frame.browsingContext.removePreloadScript(script) + ]); + } catch (error) { + debugError(error); + } + })); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/HTTPRequest.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/HTTPResponse.js +init_cjs_shim(); +var __runInitializers8 = 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 __esDecorate8 = 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 BidiHTTPResponse = (() => { + let _classSuper = HTTPResponse; + let _instanceExtraInitializers = []; + let _remoteAddress_decorators; + return class BidiHTTPResponse2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + _remoteAddress_decorators = [invokeAtMostOnceForArguments]; + __esDecorate8(this, null, _remoteAddress_decorators, { kind: "method", name: "remoteAddress", static: false, private: false, access: { has: (obj) => "remoteAddress" in obj, get: (obj) => obj.remoteAddress }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static from(data, request, cdpSupported) { + const response = new BidiHTTPResponse2(data, request, cdpSupported); + response.#initialize(); + return response; + } + #data = __runInitializers8(this, _instanceExtraInitializers); + #request; + #securityDetails; + #cdpSupported = false; + constructor(data, request, cdpSupported) { + super(); + this.#data = data; + this.#request = request; + this.#cdpSupported = cdpSupported; + const securityDetails = data["goog:securityDetails"]; + if (cdpSupported && securityDetails) { + this.#securityDetails = new SecurityDetails(securityDetails); + } + } + #initialize() { + if (this.#data.fromCache) { + this.#request._fromMemoryCache = true; + this.#request.frame()?.page().trustedEmitter.emit("requestservedfromcache", this.#request); + } + this.#request.frame()?.page().trustedEmitter.emit("response", this); + } + remoteAddress() { + return { + ip: "", + port: -1 + }; + } + url() { + return this.#data.url; + } + status() { + return this.#data.status; + } + statusText() { + return this.#data.statusText; + } + headers() { + const headers = {}; + for (const header of this.#data.headers) { + if (header.value.type === "string") { + headers[header.name.toLowerCase()] = header.value.value; + } + } + return headers; + } + request() { + return this.#request; + } + fromCache() { + return this.#data.fromCache; + } + timing() { + const bidiTiming = this.#request.timing(); + return { + requestTime: bidiTiming.requestTime, + proxyStart: -1, + proxyEnd: -1, + dnsStart: bidiTiming.dnsStart, + dnsEnd: bidiTiming.dnsEnd, + connectStart: bidiTiming.connectStart, + connectEnd: bidiTiming.connectEnd, + sslStart: bidiTiming.tlsStart, + sslEnd: -1, + workerStart: -1, + workerReady: -1, + workerFetchStart: -1, + workerRespondWithSettled: -1, + workerRouterEvaluationStart: -1, + workerCacheLookupStart: -1, + sendStart: bidiTiming.requestStart, + sendEnd: -1, + pushStart: -1, + pushEnd: -1, + receiveHeadersStart: bidiTiming.responseStart, + receiveHeadersEnd: bidiTiming.responseEnd + }; + } + frame() { + return this.#request.frame(); + } + fromServiceWorker() { + return false; + } + securityDetails() { + if (!this.#cdpSupported) { + throw new UnsupportedOperation(); + } + return this.#securityDetails ?? null; + } + content() { + throw new UnsupportedOperation(); + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/HTTPRequest.js +var _a2; +var requests = /* @__PURE__ */ new WeakMap(); +var BidiHTTPRequest = class extends HTTPRequest { + static from(bidiRequest, frame, redirect) { + const request = new _a2(bidiRequest, frame, redirect); + request.#initialize(); + return request; + } + #redirectChain; + #response = null; + id; + #frame; + #request; + constructor(request, frame, redirect) { + super(); + requests.set(request, this); + this.interception.enabled = request.isBlocked; + this.#request = request; + this.#frame = frame; + this.#redirectChain = redirect ? redirect.#redirectChain : []; + this.id = request.id; + } + get client() { + return this.#frame.client; + } + #initialize() { + this.#request.on("redirect", (request) => { + const httpRequest = _a2.from(request, this.#frame, this); + this.#redirectChain.push(this); + request.once("success", () => { + this.#frame.page().trustedEmitter.emit("requestfinished", httpRequest); + }); + request.once("error", () => { + this.#frame.page().trustedEmitter.emit("requestfailed", httpRequest); + }); + void httpRequest.finalizeInterceptions(); + }); + this.#request.once("success", (data) => { + this.#response = BidiHTTPResponse.from(data, this, this.#frame.page().browser().cdpSupported); + }); + this.#request.on("authenticate", this.#handleAuthentication); + this.#frame.page().trustedEmitter.emit("request", this); + if (this.#hasInternalHeaderOverwrite) { + this.interception.handlers.push(async () => { + await this.continue({ + headers: this.headers() + }, 0); + }); + } + } + url() { + return this.#request.url; + } + resourceType() { + if (!this.#frame.page().browser().cdpSupported) { + throw new UnsupportedOperation(); + } + return (this.#request.resourceType || "other").toLowerCase(); + } + method() { + return this.#request.method; + } + postData() { + if (!this.#frame.page().browser().cdpSupported) { + throw new UnsupportedOperation(); + } + return this.#request.postData; + } + hasPostData() { + if (!this.#frame.page().browser().cdpSupported) { + throw new UnsupportedOperation(); + } + return this.#request.hasPostData; + } + async fetchPostData() { + throw new UnsupportedOperation(); + } + get #hasInternalHeaderOverwrite() { + return Boolean(Object.keys(this.#extraHTTPHeaders).length || Object.keys(this.#userAgentHeaders).length); + } + get #extraHTTPHeaders() { + return this.#frame?.page()._extraHTTPHeaders ?? {}; + } + get #userAgentHeaders() { + return this.#frame?.page()._userAgentHeaders ?? {}; + } + headers() { + const headers = {}; + for (const header of this.#request.headers) { + headers[header.name.toLowerCase()] = header.value.value; + } + return { + ...headers, + ...this.#extraHTTPHeaders, + ...this.#userAgentHeaders + }; + } + response() { + return this.#response; + } + failure() { + if (this.#request.error === void 0) { + return null; + } + return { errorText: this.#request.error }; + } + isNavigationRequest() { + return this.#request.navigation !== void 0; + } + initiator() { + return this.#request.initiator; + } + redirectChain() { + return this.#redirectChain.slice(); + } + frame() { + return this.#frame; + } + async continue(overrides, priority) { + return await super.continue({ + headers: this.#hasInternalHeaderOverwrite ? this.headers() : void 0, + ...overrides + }, priority); + } + async _continue(overrides = {}) { + const headers = getBidiHeaders(overrides.headers); + this.interception.handled = true; + return await this.#request.continueRequest({ + url: overrides.url, + method: overrides.method, + body: overrides.postData ? { + type: "base64", + value: stringToBase64(overrides.postData) + } : void 0, + headers: headers.length > 0 ? headers : void 0 + }).catch((error) => { + this.interception.handled = false; + return handleError(error); + }); + } + async _abort() { + this.interception.handled = true; + return await this.#request.failRequest().catch((error) => { + this.interception.handled = false; + throw error; + }); + } + async _respond(response, _priority) { + this.interception.handled = true; + let parsedBody; + if (response.body) { + parsedBody = HTTPRequest.getResponse(response.body); + } + const headers = getBidiHeaders(response.headers); + const hasContentLength = headers.some((header) => { + return header.name === "content-length"; + }); + if (response.contentType) { + headers.push({ + name: "content-type", + value: { + type: "string", + value: response.contentType + } + }); + } + if (parsedBody?.contentLength && !hasContentLength) { + headers.push({ + name: "content-length", + value: { + type: "string", + value: String(parsedBody.contentLength) + } + }); + } + const status = response.status || 200; + return await this.#request.provideResponse({ + statusCode: status, + headers: headers.length > 0 ? headers : void 0, + reasonPhrase: STATUS_TEXTS[status], + body: parsedBody?.base64 ? { + type: "base64", + value: parsedBody?.base64 + } : void 0 + }).catch((error) => { + this.interception.handled = false; + throw error; + }); + } + #authenticationHandled = false; + #handleAuthentication = async () => { + if (!this.#frame) { + return; + } + const credentials = this.#frame.page()._credentials; + if (credentials && !this.#authenticationHandled) { + this.#authenticationHandled = true; + void this.#request.continueWithAuth({ + action: "provideCredentials", + credentials: { + type: "password", + username: credentials.username, + password: credentials.password + } + }); + } else { + void this.#request.continueWithAuth({ + action: "cancel" + }); + } + }; + timing() { + return this.#request.timing(); + } +}; +_a2 = BidiHTTPRequest; +function getBidiHeaders(rawHeaders) { + const headers = []; + for (const [name, value] of Object.entries(rawHeaders ?? [])) { + if (!Object.is(value, void 0)) { + const values = Array.isArray(value) ? value : [value]; + for (const value2 of values) { + headers.push({ + name: name.toLowerCase(), + value: { + type: "string", + value: String(value2) + } + }); + } + } + } + return headers; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Realm.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Serializer.js +init_cjs_shim(); +var UnserializableError = class extends Error { +}; +var _serializeNumber, serializeNumber_fn, _serializeObject, serializeObject_fn; +var BidiSerializer = class { + static serialize(arg) { + switch (typeof arg) { + case "symbol": + case "function": + throw new UnserializableError(`Unable to serializable ${typeof arg}`); + case "object": + return __privateMethod(this, _serializeObject, serializeObject_fn).call(this, arg); + case "undefined": + return { + type: "undefined" + }; + case "number": + return __privateMethod(this, _serializeNumber, serializeNumber_fn).call(this, arg); + case "bigint": + return { + type: "bigint", + value: arg.toString() + }; + case "string": + return { + type: "string", + value: arg + }; + case "boolean": + return { + type: "boolean", + value: arg + }; + } + } +}; +_serializeNumber = new WeakSet(); +serializeNumber_fn = function(arg) { + let value; + if (Object.is(arg, -0)) { + value = "-0"; + } else if (Object.is(arg, Infinity)) { + value = "Infinity"; + } else if (Object.is(arg, -Infinity)) { + value = "-Infinity"; + } else if (Object.is(arg, NaN)) { + value = "NaN"; + } else { + value = arg; + } + return { + type: "number", + value + }; +}; +_serializeObject = new WeakSet(); +serializeObject_fn = function(arg) { + if (arg === null) { + return { + type: "null" + }; + } else if (Array.isArray(arg)) { + const parsedArray = arg.map((subArg) => { + return this.serialize(subArg); + }); + return { + type: "array", + value: parsedArray + }; + } else if (isPlainObject(arg)) { + try { + JSON.stringify(arg); + } catch (error) { + if (error instanceof TypeError && error.message.startsWith("Converting circular structure to JSON")) { + error.message += " Recursive objects are not allowed."; + } + throw error; + } + const parsedObject = []; + for (const key in arg) { + parsedObject.push([this.serialize(key), this.serialize(arg[key])]); + } + return { + type: "object", + value: parsedObject + }; + } else if (isRegExp(arg)) { + return { + type: "regexp", + value: { + pattern: arg.source, + flags: arg.flags + } + }; + } else if (isDate(arg)) { + return { + type: "date", + value: arg.toISOString() + }; + } + throw new UnserializableError("Custom object serialization not possible. Use plain objects instead."); +}; +__privateAdd(BidiSerializer, _serializeNumber); +__privateAdd(BidiSerializer, _serializeObject); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/util.js +init_cjs_shim(); +function createEvaluationError(details) { + if (details.exception.type !== "error") { + return BidiDeserializer.deserialize(details.exception); + } + const [name = "", ...parts] = details.text.split(": "); + const message = parts.join(": "); + const error = new Error(message); + error.name = name; + const stackLines = []; + if (details.stackTrace && stackLines.length < Error.stackTraceLimit) { + for (const frame of details.stackTrace.callFrames.reverse()) { + if (PuppeteerURL.isPuppeteerURL(frame.url) && frame.url !== PuppeteerURL.INTERNAL_URL) { + const url = PuppeteerURL.parse(frame.url); + stackLines.unshift(` at ${frame.functionName || url.functionName} (${url.functionName} at ${url.siteString}, :${frame.lineNumber}:${frame.columnNumber})`); + } else { + stackLines.push(` at ${frame.functionName || ""} (${frame.url}:${frame.lineNumber}:${frame.columnNumber})`); + } + if (stackLines.length >= Error.stackTraceLimit) { + break; + } + } + } + error.stack = [details.text, ...stackLines].join("\n"); + return error; +} +function rewriteNavigationError(message, ms) { + return (error) => { + if (error instanceof ProtocolError) { + error.message += ` at ${message}`; + } else if (error instanceof TimeoutError) { + error.message = `Navigation timeout of ${ms} ms exceeded`; + } + throw error; + }; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Realm.js +var __addDisposableResource3 = function(env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env.stack.push({ value, dispose, async }); + } else if (async) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources3 = function(SuppressedError2) { + return function(env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) + throw env.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var BidiRealm = class extends Realm { + realm; + constructor(realm, timeoutSettings) { + super(timeoutSettings); + this.realm = realm; + } + initialize() { + this.realm.on("destroyed", ({ reason }) => { + this.taskManager.terminateAll(new Error(reason)); + this.dispose(); + }); + this.realm.on("updated", () => { + this.internalPuppeteerUtil = void 0; + void this.taskManager.rerunAll(); + }); + } + internalPuppeteerUtil; + get puppeteerUtil() { + const promise = Promise.resolve(); + scriptInjector.inject((script) => { + if (this.internalPuppeteerUtil) { + void this.internalPuppeteerUtil.then((handle) => { + void handle.dispose(); + }); + } + this.internalPuppeteerUtil = promise.then(() => { + return this.evaluateHandle(script); + }); + }, !this.internalPuppeteerUtil); + return this.internalPuppeteerUtil; + } + async evaluateHandle(pageFunction, ...args) { + return await this.#evaluate(false, pageFunction, ...args); + } + async evaluate(pageFunction, ...args) { + return await this.#evaluate(true, pageFunction, ...args); + } + async #evaluate(returnByValue, pageFunction, ...args) { + const sourceUrlComment = getSourceUrlComment(getSourcePuppeteerURLIfAvailable(pageFunction)?.toString() ?? PuppeteerURL.INTERNAL_URL); + let responsePromise; + const resultOwnership = returnByValue ? "none" : "root"; + const serializationOptions = returnByValue ? {} : { + maxObjectDepth: 0, + maxDomDepth: 0 + }; + if (isString(pageFunction)) { + const expression = SOURCE_URL_REGEX.test(pageFunction) ? pageFunction : `${pageFunction} +${sourceUrlComment} +`; + responsePromise = this.realm.evaluate(expression, true, { + resultOwnership, + userActivation: true, + serializationOptions + }); + } else { + let functionDeclaration = stringifyFunction(pageFunction); + functionDeclaration = SOURCE_URL_REGEX.test(functionDeclaration) ? functionDeclaration : `${functionDeclaration} +${sourceUrlComment} +`; + responsePromise = this.realm.callFunction( + functionDeclaration, + /* awaitPromise= */ + true, + { + // LazyArgs are used only internally and should not affect the order + // evaluate calls for the public APIs. + arguments: args.some((arg) => { + return arg instanceof LazyArg; + }) ? await Promise.all(args.map((arg) => { + return this.serializeAsync(arg); + })) : args.map((arg) => { + return this.serialize(arg); + }), + resultOwnership, + userActivation: true, + serializationOptions + } + ); + } + const result = await responsePromise; + if ("type" in result && result.type === "exception") { + throw createEvaluationError(result.exceptionDetails); + } + return returnByValue ? BidiDeserializer.deserialize(result.result) : this.createHandle(result.result); + } + createHandle(result) { + if ((result.type === "node" || result.type === "window") && this instanceof BidiFrameRealm) { + return BidiElementHandle.from(result, this); + } + return BidiJSHandle.from(result, this); + } + async serializeAsync(arg) { + if (arg instanceof LazyArg) { + arg = await arg.get(this); + } + return this.serialize(arg); + } + serialize(arg) { + if (arg instanceof BidiJSHandle || arg instanceof BidiElementHandle) { + if (arg.realm !== this) { + if (!(arg.realm instanceof BidiFrameRealm) || !(this instanceof BidiFrameRealm)) { + throw new Error("Trying to evaluate JSHandle from different global types. Usually this means you're using a handle from a worker in a page or vice versa."); + } + if (arg.realm.environment !== this.environment) { + throw new Error("Trying to evaluate JSHandle from different frames. Usually this means you're using a handle from a page on a different page."); + } + } + if (arg.disposed) { + throw new Error("JSHandle is disposed!"); + } + return arg.remoteValue(); + } + return BidiSerializer.serialize(arg); + } + async destroyHandles(handles) { + if (this.disposed) { + return; + } + const handleIds = handles.map(({ id }) => { + return id; + }).filter((id) => { + return id !== void 0; + }); + if (handleIds.length === 0) { + return; + } + await this.realm.disown(handleIds).catch((error) => { + debugError(error); + }); + } + async adoptHandle(handle) { + return await this.evaluateHandle((node) => { + return node; + }, handle); + } + async transferHandle(handle) { + if (handle.realm === this) { + return handle; + } + const transferredHandle = this.adoptHandle(handle); + await handle.dispose(); + return await transferredHandle; + } +}; +var BidiFrameRealm = class extends BidiRealm { + static from(realm, frame) { + const frameRealm = new BidiFrameRealm(realm, frame); + frameRealm.#initialize(); + return frameRealm; + } + #frame; + constructor(realm, frame) { + super(realm, frame.timeoutSettings); + this.#frame = frame; + } + #initialize() { + super.initialize(); + this.realm.on("updated", () => { + this.environment.clearDocumentHandle(); + this.#bindingsInstalled = false; + }); + } + #bindingsInstalled = false; + get puppeteerUtil() { + let promise = Promise.resolve(); + if (!this.#bindingsInstalled) { + promise = Promise.all([ + ExposeableFunction.from(this.environment, "__ariaQuerySelector", ARIAQueryHandler.queryOne, !!this.sandbox), + ExposeableFunction.from(this.environment, "__ariaQuerySelectorAll", async (element, selector) => { + const results = ARIAQueryHandler.queryAll(element, selector); + return await element.realm.evaluateHandle((...elements) => { + return elements; + }, ...await AsyncIterableUtil.collect(results)); + }, !!this.sandbox) + ]); + this.#bindingsInstalled = true; + } + return promise.then(() => { + return super.puppeteerUtil; + }); + } + get sandbox() { + return this.realm.sandbox; + } + get environment() { + return this.#frame; + } + async adoptBackendNode(backendNodeId) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const { object } = await this.#frame.client.send("DOM.resolveNode", { + backendNodeId, + executionContextId: await this.realm.resolveExecutionContextId() + }); + const handle = __addDisposableResource3(env_1, BidiElementHandle.from({ + handle: object.objectId, + type: "node" + }, this), false); + return await handle.evaluateHandle((element) => { + return element; + }); + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources3(env_1); + } + } +}; +var BidiWorkerRealm = class extends BidiRealm { + static from(realm, worker) { + const workerRealm = new BidiWorkerRealm(realm, worker); + workerRealm.initialize(); + return workerRealm; + } + #worker; + constructor(realm, frame) { + super(realm, frame.timeoutSettings); + this.#worker = frame; + } + get environment() { + return this.#worker; + } + async adoptBackendNode() { + throw new Error("Cannot adopt DOM nodes into a worker."); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/WebWorker.js +init_cjs_shim(); +var BidiWebWorker = class extends WebWorker { + static from(frame, realm) { + const worker = new BidiWebWorker(frame, realm); + return worker; + } + #frame; + #realm; + constructor(frame, realm) { + super(realm.origin); + this.#frame = frame; + this.#realm = BidiWorkerRealm.from(realm, this); + } + get frame() { + return this.#frame; + } + mainRealm() { + return this.#realm; + } + get client() { + throw new UnsupportedOperation(); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Frame.js +var __runInitializers9 = 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 __esDecorate9 = 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 = 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 }); +}; +function convertConsoleMessageLevel(method) { + switch (method) { + case "group": + return "startGroup"; + case "groupCollapsed": + return "startGroupCollapsed"; + case "groupEnd": + return "endGroup"; + default: + return method; + } +} +var BidiFrame = (() => { + var _a3; + let _classSuper = Frame; + let _instanceExtraInitializers = []; + let _goto_decorators; + let _setContent_decorators; + let _waitForNavigation_decorators; + let _private_waitForLoad$_decorators; + let _private_waitForLoad$_descriptor; + let _private_waitForNetworkIdle$_decorators; + let _private_waitForNetworkIdle$_descriptor; + let _setFiles_decorators; + let _locateNodes_decorators; + return class BidiFrame2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + _goto_decorators = [throwIfDetached]; + _setContent_decorators = [throwIfDetached]; + _waitForNavigation_decorators = [throwIfDetached]; + _private_waitForLoad$_decorators = [throwIfDetached]; + _private_waitForNetworkIdle$_decorators = [throwIfDetached]; + _setFiles_decorators = [throwIfDetached]; + _locateNodes_decorators = [throwIfDetached]; + __esDecorate9(this, null, _goto_decorators, { kind: "method", name: "goto", static: false, private: false, access: { has: (obj) => "goto" in obj, get: (obj) => obj.goto }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate9(this, null, _setContent_decorators, { kind: "method", name: "setContent", static: false, private: false, access: { has: (obj) => "setContent" in obj, get: (obj) => obj.setContent }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate9(this, null, _waitForNavigation_decorators, { kind: "method", name: "waitForNavigation", static: false, private: false, access: { has: (obj) => "waitForNavigation" in obj, get: (obj) => obj.waitForNavigation }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate9(this, _private_waitForLoad$_descriptor = { value: __setFunctionName(function(options = {}) { + let { waitUntil = "load" } = options; + const { timeout: ms = this.timeoutSettings.navigationTimeout() } = options; + if (!Array.isArray(waitUntil)) { + waitUntil = [waitUntil]; + } + const events = /* @__PURE__ */ new Set(); + for (const lifecycleEvent of waitUntil) { + switch (lifecycleEvent) { + case "load": { + events.add("load"); + break; + } + case "domcontentloaded": { + events.add("DOMContentLoaded"); + break; + } + } + } + if (events.size === 0) { + return of(void 0); + } + return combineLatest([...events].map((event) => { + return fromEmitterEvent(this.browsingContext, event); + })).pipe(map(() => { + }), first(), raceWith(timeout(ms), this.#detached$().pipe(map(() => { + throw new Error("Frame detached."); + })))); + }, "#waitForLoad$") }, _private_waitForLoad$_decorators, { kind: "method", name: "#waitForLoad$", static: false, private: true, access: { has: (obj) => #waitForLoad$ in obj, get: (obj) => obj.#waitForLoad$ }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate9(this, _private_waitForNetworkIdle$_descriptor = { value: __setFunctionName(function(options = {}) { + let { waitUntil = "load" } = options; + if (!Array.isArray(waitUntil)) { + waitUntil = [waitUntil]; + } + let concurrency = Infinity; + for (const event of waitUntil) { + switch (event) { + case "networkidle0": { + concurrency = Math.min(0, concurrency); + break; + } + case "networkidle2": { + concurrency = Math.min(2, concurrency); + break; + } + } + } + if (concurrency === Infinity) { + return of(void 0); + } + return this.page().waitForNetworkIdle$({ + idleTime: 500, + timeout: options.timeout ?? this.timeoutSettings.timeout(), + concurrency + }); + }, "#waitForNetworkIdle$") }, _private_waitForNetworkIdle$_decorators, { kind: "method", name: "#waitForNetworkIdle$", static: false, private: true, access: { has: (obj) => #waitForNetworkIdle$ in obj, get: (obj) => obj.#waitForNetworkIdle$ }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate9(this, null, _setFiles_decorators, { kind: "method", name: "setFiles", static: false, private: false, access: { has: (obj) => "setFiles" in obj, get: (obj) => obj.setFiles }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate9(this, null, _locateNodes_decorators, { kind: "method", name: "locateNodes", static: false, private: false, access: { has: (obj) => "locateNodes" in obj, get: (obj) => obj.locateNodes }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static from(parent, browsingContext) { + const frame = new BidiFrame2(parent, browsingContext); + frame.#initialize(); + return frame; + } + #parent = __runInitializers9(this, _instanceExtraInitializers); + browsingContext; + #frames = /* @__PURE__ */ new WeakMap(); + realms; + _id; + client; + accessibility; + constructor(parent, browsingContext) { + super(); + this.#parent = parent; + this.browsingContext = browsingContext; + this._id = browsingContext.id; + this.client = new BidiCdpSession(this); + this.realms = { + default: BidiFrameRealm.from(this.browsingContext.defaultRealm, this), + internal: BidiFrameRealm.from(this.browsingContext.createWindowRealm(`__puppeteer_internal_${Math.ceil(Math.random() * 1e4)}`), this) + }; + this.accessibility = new Accessibility(this.realms.default); + } + #initialize() { + for (const browsingContext of this.browsingContext.children) { + this.#createFrameTarget(browsingContext); + } + this.browsingContext.on("browsingcontext", ({ browsingContext }) => { + this.#createFrameTarget(browsingContext); + }); + this.browsingContext.on("closed", () => { + for (const session of BidiCdpSession.sessions.values()) { + if (session.frame === this) { + session.onClose(); + } + } + this.page().trustedEmitter.emit("framedetached", this); + }); + this.browsingContext.on("request", ({ request }) => { + const httpRequest = BidiHTTPRequest.from(request, this); + request.once("success", () => { + this.page().trustedEmitter.emit("requestfinished", httpRequest); + }); + request.once("error", () => { + this.page().trustedEmitter.emit("requestfailed", httpRequest); + }); + void httpRequest.finalizeInterceptions(); + }); + this.browsingContext.on("navigation", ({ navigation }) => { + navigation.once("fragment", () => { + this.page().trustedEmitter.emit("framenavigated", this); + }); + }); + this.browsingContext.on("load", () => { + this.page().trustedEmitter.emit("load", void 0); + }); + this.browsingContext.on("DOMContentLoaded", () => { + this._hasStartedLoading = true; + this.page().trustedEmitter.emit("domcontentloaded", void 0); + this.page().trustedEmitter.emit("framenavigated", this); + }); + this.browsingContext.on("userprompt", ({ userPrompt }) => { + this.page().trustedEmitter.emit("dialog", BidiDialog.from(userPrompt)); + }); + this.browsingContext.on("log", ({ entry }) => { + if (this._id !== entry.source.context) { + return; + } + if (isConsoleLogEntry(entry)) { + const args = entry.args.map((arg) => { + return this.mainRealm().createHandle(arg); + }); + const text = args.reduce((value, arg) => { + const parsedValue = arg instanceof BidiJSHandle && arg.isPrimitiveValue ? BidiDeserializer.deserialize(arg.remoteValue()) : arg.toString(); + return `${value} ${parsedValue}`; + }, "").slice(1); + this.page().trustedEmitter.emit("console", new ConsoleMessage(convertConsoleMessageLevel(entry.method), text, args, getStackTraceLocations(entry.stackTrace), this)); + } else if (isJavaScriptLogEntry(entry)) { + const error = new Error(entry.text ?? ""); + const messageHeight = error.message.split("\n").length; + const messageLines = error.stack.split("\n").splice(0, messageHeight); + const stackLines = []; + if (entry.stackTrace) { + for (const frame of entry.stackTrace.callFrames) { + stackLines.push(` at ${frame.functionName || ""} (${frame.url}:${frame.lineNumber + 1}:${frame.columnNumber + 1})`); + if (stackLines.length >= Error.stackTraceLimit) { + break; + } + } + } + error.stack = [...messageLines, ...stackLines].join("\n"); + this.page().trustedEmitter.emit("pageerror", error); + } else { + debugError(`Unhandled LogEntry with type "${entry.type}", text "${entry.text}" and level "${entry.level}"`); + } + }); + this.browsingContext.on("worker", ({ realm }) => { + const worker = BidiWebWorker.from(this, realm); + realm.on("destroyed", () => { + this.page().trustedEmitter.emit("workerdestroyed", worker); + }); + this.page().trustedEmitter.emit("workercreated", worker); + }); + } + #createFrameTarget(browsingContext) { + const frame = BidiFrame2.from(this, browsingContext); + this.#frames.set(browsingContext, frame); + this.page().trustedEmitter.emit("frameattached", frame); + browsingContext.on("closed", () => { + this.#frames.delete(browsingContext); + }); + return frame; + } + get timeoutSettings() { + return this.page()._timeoutSettings; + } + mainRealm() { + return this.realms.default; + } + isolatedRealm() { + return this.realms.internal; + } + realm(id) { + for (const realm of Object.values(this.realms)) { + if (realm.realm.id === id) { + return realm; + } + } + return; + } + page() { + let parent = this.#parent; + while (parent instanceof BidiFrame2) { + parent = parent.#parent; + } + return parent; + } + url() { + return this.browsingContext.url; + } + parentFrame() { + if (this.#parent instanceof BidiFrame2) { + return this.#parent; + } + return null; + } + childFrames() { + return [...this.browsingContext.children].map((child) => { + return this.#frames.get(child); + }); + } + #detached$() { + return defer(() => { + if (this.detached) { + return of(this); + } + return fromEmitterEvent( + this.page().trustedEmitter, + "framedetached" + /* PageEvent.FrameDetached */ + ).pipe(filter((detachedFrame) => { + return detachedFrame === this; + })); + }); + } + async goto(url, options = {}) { + const [response] = await Promise.all([ + this.waitForNavigation(options), + // Some implementations currently only report errors when the + // readiness=interactive. + // + // Related: https://bugzilla.mozilla.org/show_bug.cgi?id=1846601 + this.browsingContext.navigate( + url, + "interactive" + /* Bidi.BrowsingContext.ReadinessState.Interactive */ + ).catch((error) => { + if (isErrorLike(error) && error.message.includes("net::ERR_HTTP_RESPONSE_CODE_FAILURE")) { + return; + } + if (error.message.includes("navigation canceled")) { + return; + } + throw error; + }) + ]).catch(rewriteNavigationError(url, options.timeout ?? this.timeoutSettings.navigationTimeout())); + return response; + } + async setContent(html, options = {}) { + await Promise.all([ + this.setFrameContent(html), + firstValueFrom(combineLatest([ + this.#waitForLoad$(options), + this.#waitForNetworkIdle$(options) + ])) + ]); + } + async waitForNavigation(options = {}) { + const { timeout: ms = this.timeoutSettings.navigationTimeout(), signal } = options; + const frames = this.childFrames().map((frame) => { + return frame.#detached$(); + }); + return await firstValueFrom(combineLatest([ + fromEmitterEvent(this.browsingContext, "navigation").pipe(first()).pipe(switchMap(({ navigation }) => { + return this.#waitForLoad$(options).pipe(delayWhen(() => { + if (frames.length === 0) { + return of(void 0); + } + return combineLatest(frames); + }), raceWith(fromEmitterEvent(navigation, "fragment"), fromEmitterEvent(navigation, "failed"), fromEmitterEvent(navigation, "aborted").pipe(map(({ url }) => { + throw new Error(`Navigation aborted: ${url}`); + }))), switchMap(() => { + if (navigation.request) { + let requestFinished$ = function(request) { + if (request.response || request.error) { + return of(navigation); + } + if (request.redirect) { + return requestFinished$(request.redirect); + } + return fromEmitterEvent(request, "success").pipe(raceWith(fromEmitterEvent(request, "error")), raceWith(fromEmitterEvent(request, "redirect"))).pipe(switchMap(() => { + return requestFinished$(request); + })); + }; + return requestFinished$(navigation.request); + } + return of(navigation); + })); + })), + this.#waitForNetworkIdle$(options) + ]).pipe(map(([navigation]) => { + const request = navigation.request; + if (!request) { + return null; + } + const lastRequest = request.lastRedirect ?? request; + const httpRequest = requests.get(lastRequest); + return httpRequest.response(); + }), raceWith(timeout(ms), fromAbortSignal(signal), this.#detached$().pipe(map(() => { + throw new TargetCloseError("Frame detached."); + }))))); + } + waitForDevicePrompt() { + throw new UnsupportedOperation(); + } + get detached() { + return this.browsingContext.closed; + } + #exposedFunctions = /* @__PURE__ */ new Map(); + async exposeFunction(name, apply) { + if (this.#exposedFunctions.has(name)) { + throw new Error(`Failed to add page binding with name ${name}: globalThis['${name}'] already exists!`); + } + const exposeable = await ExposeableFunction.from(this, name, apply); + this.#exposedFunctions.set(name, exposeable); + } + async removeExposedFunction(name) { + const exposedFunction = this.#exposedFunctions.get(name); + if (!exposedFunction) { + throw new Error(`Failed to remove page binding with name ${name}: window['${name}'] does not exists!`); + } + this.#exposedFunctions.delete(name); + await exposedFunction[Symbol.asyncDispose](); + } + async createCDPSession() { + if (!this.page().browser().cdpSupported) { + throw new UnsupportedOperation(); + } + const cdpConnection = this.page().browser().cdpConnection; + return await cdpConnection._createSession({ targetId: this._id }); + } + get #waitForLoad$() { + return _private_waitForLoad$_descriptor.value; + } + get #waitForNetworkIdle$() { + return _private_waitForNetworkIdle$_descriptor.value; + } + async setFiles(element, files) { + await this.browsingContext.setFiles( + // SAFETY: ElementHandles are always remote references. + element.remoteValue(), + files + ); + } + async locateNodes(element, locator) { + return await this.browsingContext.locateNodes( + locator, + // SAFETY: ElementHandles are always remote references. + [element.remoteValue()] + ); + } + }; +})(); +function isConsoleLogEntry(event) { + return event.type === "console"; +} +function isJavaScriptLogEntry(event) { + return event.type === "javascript"; +} +function getStackTraceLocations(stackTrace) { + const stackTraceLocations = []; + if (stackTrace) { + for (const callFrame of stackTrace.callFrames) { + stackTraceLocations.push({ + url: callFrame.url, + lineNumber: callFrame.lineNumber, + columnNumber: callFrame.columnNumber + }); + } + } + return stackTraceLocations; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Input.js +init_cjs_shim(); +var SourceActionsType; +(function(SourceActionsType2) { + SourceActionsType2["None"] = "none"; + SourceActionsType2["Key"] = "key"; + SourceActionsType2["Pointer"] = "pointer"; + SourceActionsType2["Wheel"] = "wheel"; +})(SourceActionsType || (SourceActionsType = {})); +var ActionType; +(function(ActionType2) { + ActionType2["Pause"] = "pause"; + ActionType2["KeyDown"] = "keyDown"; + ActionType2["KeyUp"] = "keyUp"; + ActionType2["PointerUp"] = "pointerUp"; + ActionType2["PointerDown"] = "pointerDown"; + ActionType2["PointerMove"] = "pointerMove"; + ActionType2["Scroll"] = "scroll"; +})(ActionType || (ActionType = {})); +var getBidiKeyValue = (key) => { + switch (key) { + case "\r": + case "\n": + key = "Enter"; + break; + } + if ([...key].length === 1) { + return key; + } + switch (key) { + case "Cancel": + return "\uE001"; + case "Help": + return "\uE002"; + case "Backspace": + return "\uE003"; + case "Tab": + return "\uE004"; + case "Clear": + return "\uE005"; + case "Enter": + return "\uE007"; + case "Shift": + case "ShiftLeft": + return "\uE008"; + case "Control": + case "ControlLeft": + return "\uE009"; + case "Alt": + case "AltLeft": + return "\uE00A"; + case "Pause": + return "\uE00B"; + case "Escape": + return "\uE00C"; + case "PageUp": + return "\uE00E"; + case "PageDown": + return "\uE00F"; + case "End": + return "\uE010"; + case "Home": + return "\uE011"; + case "ArrowLeft": + return "\uE012"; + case "ArrowUp": + return "\uE013"; + case "ArrowRight": + return "\uE014"; + case "ArrowDown": + return "\uE015"; + case "Insert": + return "\uE016"; + case "Delete": + return "\uE017"; + case "NumpadEqual": + return "\uE019"; + case "Numpad0": + return "\uE01A"; + case "Numpad1": + return "\uE01B"; + case "Numpad2": + return "\uE01C"; + case "Numpad3": + return "\uE01D"; + case "Numpad4": + return "\uE01E"; + case "Numpad5": + return "\uE01F"; + case "Numpad6": + return "\uE020"; + case "Numpad7": + return "\uE021"; + case "Numpad8": + return "\uE022"; + case "Numpad9": + return "\uE023"; + case "NumpadMultiply": + return "\uE024"; + case "NumpadAdd": + return "\uE025"; + case "NumpadSubtract": + return "\uE027"; + case "NumpadDecimal": + return "\uE028"; + case "NumpadDivide": + return "\uE029"; + case "F1": + return "\uE031"; + case "F2": + return "\uE032"; + case "F3": + return "\uE033"; + case "F4": + return "\uE034"; + case "F5": + return "\uE035"; + case "F6": + return "\uE036"; + case "F7": + return "\uE037"; + case "F8": + return "\uE038"; + case "F9": + return "\uE039"; + case "F10": + return "\uE03A"; + case "F11": + return "\uE03B"; + case "F12": + return "\uE03C"; + case "Meta": + case "MetaLeft": + return "\uE03D"; + case "ShiftRight": + return "\uE050"; + case "ControlRight": + return "\uE051"; + case "AltRight": + return "\uE052"; + case "MetaRight": + return "\uE053"; + case "Digit0": + return "0"; + case "Digit1": + return "1"; + case "Digit2": + return "2"; + case "Digit3": + return "3"; + case "Digit4": + return "4"; + case "Digit5": + return "5"; + case "Digit6": + return "6"; + case "Digit7": + return "7"; + case "Digit8": + return "8"; + case "Digit9": + return "9"; + case "KeyA": + return "a"; + case "KeyB": + return "b"; + case "KeyC": + return "c"; + case "KeyD": + return "d"; + case "KeyE": + return "e"; + case "KeyF": + return "f"; + case "KeyG": + return "g"; + case "KeyH": + return "h"; + case "KeyI": + return "i"; + case "KeyJ": + return "j"; + case "KeyK": + return "k"; + case "KeyL": + return "l"; + case "KeyM": + return "m"; + case "KeyN": + return "n"; + case "KeyO": + return "o"; + case "KeyP": + return "p"; + case "KeyQ": + return "q"; + case "KeyR": + return "r"; + case "KeyS": + return "s"; + case "KeyT": + return "t"; + case "KeyU": + return "u"; + case "KeyV": + return "v"; + case "KeyW": + return "w"; + case "KeyX": + return "x"; + case "KeyY": + return "y"; + case "KeyZ": + return "z"; + case "Semicolon": + return ";"; + case "Equal": + return "="; + case "Comma": + return ","; + case "Minus": + return "-"; + case "Period": + return "."; + case "Slash": + return "/"; + case "Backquote": + return "`"; + case "BracketLeft": + return "["; + case "Backslash": + return "\\"; + case "BracketRight": + return "]"; + case "Quote": + return '"'; + default: + throw new Error(`Unknown key: "${key}"`); + } +}; +var BidiKeyboard = class extends Keyboard { + #page; + constructor(page) { + super(); + this.#page = page; + } + async down(key, _options) { + await this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Key, + id: "__puppeteer_keyboard", + actions: [ + { + type: ActionType.KeyDown, + value: getBidiKeyValue(key) + } + ] + } + ]); + } + async up(key) { + await this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Key, + id: "__puppeteer_keyboard", + actions: [ + { + type: ActionType.KeyUp, + value: getBidiKeyValue(key) + } + ] + } + ]); + } + async press(key, options = {}) { + const { delay = 0 } = options; + const actions = [ + { + type: ActionType.KeyDown, + value: getBidiKeyValue(key) + } + ]; + if (delay > 0) { + actions.push({ + type: ActionType.Pause, + duration: delay + }); + } + actions.push({ + type: ActionType.KeyUp, + value: getBidiKeyValue(key) + }); + await this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Key, + id: "__puppeteer_keyboard", + actions + } + ]); + } + async type(text, options = {}) { + const { delay = 0 } = options; + const values = [...text].map(getBidiKeyValue); + const actions = []; + if (delay <= 0) { + for (const value of values) { + actions.push({ + type: ActionType.KeyDown, + value + }, { + type: ActionType.KeyUp, + value + }); + } + } else { + for (const value of values) { + actions.push({ + type: ActionType.KeyDown, + value + }, { + type: ActionType.Pause, + duration: delay + }, { + type: ActionType.KeyUp, + value + }); + } + } + await this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Key, + id: "__puppeteer_keyboard", + actions + } + ]); + } + async sendCharacter(char) { + if ([...char].length > 1) { + throw new Error("Cannot send more than 1 character."); + } + const frame = await this.#page.focusedFrame(); + await frame.isolatedRealm().evaluate(async (char2) => { + document.execCommand("insertText", false, char2); + }, char); + } +}; +var getBidiButton = (button) => { + switch (button) { + case MouseButton.Left: + return 0; + case MouseButton.Middle: + return 1; + case MouseButton.Right: + return 2; + case MouseButton.Back: + return 3; + case MouseButton.Forward: + return 4; + } +}; +var BidiMouse = class extends Mouse { + #page; + #lastMovePoint = { x: 0, y: 0 }; + constructor(page) { + super(); + this.#page = page; + } + async reset() { + this.#lastMovePoint = { x: 0, y: 0 }; + await this.#page.mainFrame().browsingContext.releaseActions(); + } + async move(x, y, options = {}) { + const from2 = this.#lastMovePoint; + const to = { + x: Math.round(x), + y: Math.round(y) + }; + const actions = []; + const steps = options.steps ?? 0; + for (let i = 0; i < steps; ++i) { + actions.push({ + type: ActionType.PointerMove, + x: from2.x + (to.x - from2.x) * (i / steps), + y: from2.y + (to.y - from2.y) * (i / steps), + origin: options.origin + }); + } + actions.push({ + type: ActionType.PointerMove, + ...to, + origin: options.origin + }); + this.#lastMovePoint = to; + await this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Pointer, + id: "__puppeteer_mouse", + actions + } + ]); + } + async down(options = {}) { + await this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Pointer, + id: "__puppeteer_mouse", + actions: [ + { + type: ActionType.PointerDown, + button: getBidiButton(options.button ?? MouseButton.Left) + } + ] + } + ]); + } + async up(options = {}) { + await this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Pointer, + id: "__puppeteer_mouse", + actions: [ + { + type: ActionType.PointerUp, + button: getBidiButton(options.button ?? MouseButton.Left) + } + ] + } + ]); + } + async click(x, y, options = {}) { + const actions = [ + { + type: ActionType.PointerMove, + x: Math.round(x), + y: Math.round(y), + origin: options.origin + } + ]; + const pointerDownAction = { + type: ActionType.PointerDown, + button: getBidiButton(options.button ?? MouseButton.Left) + }; + const pointerUpAction = { + type: ActionType.PointerUp, + button: pointerDownAction.button + }; + for (let i = 1; i < (options.count ?? 1); ++i) { + actions.push(pointerDownAction, pointerUpAction); + } + actions.push(pointerDownAction); + if (options.delay) { + actions.push({ + type: ActionType.Pause, + duration: options.delay + }); + } + actions.push(pointerUpAction); + await this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Pointer, + id: "__puppeteer_mouse", + actions + } + ]); + } + async wheel(options = {}) { + await this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Wheel, + id: "__puppeteer_wheel", + actions: [ + { + type: ActionType.Scroll, + ...this.#lastMovePoint ?? { + x: 0, + y: 0 + }, + deltaX: options.deltaX ?? 0, + deltaY: options.deltaY ?? 0 + } + ] + } + ]); + } + drag() { + throw new UnsupportedOperation(); + } + dragOver() { + throw new UnsupportedOperation(); + } + dragEnter() { + throw new UnsupportedOperation(); + } + drop() { + throw new UnsupportedOperation(); + } + dragAndDrop() { + throw new UnsupportedOperation(); + } +}; +var BidiTouchHandle = class { + #started = false; + #x; + #y; + #bidiId; + #page; + #touchScreen; + #properties; + constructor(page, touchScreen, id, x, y, properties) { + this.#page = page; + this.#touchScreen = touchScreen; + this.#x = Math.round(x); + this.#y = Math.round(y); + this.#properties = properties; + this.#bidiId = `${"__puppeteer_finger"}_${id}`; + } + async start(options = {}) { + if (this.#started) { + throw new TouchError("Touch has already started"); + } + await this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Pointer, + id: this.#bidiId, + parameters: { + pointerType: "touch" + }, + actions: [ + { + type: ActionType.PointerMove, + x: this.#x, + y: this.#y, + origin: options.origin + }, + { + ...this.#properties, + type: ActionType.PointerDown, + button: 0 + } + ] + } + ]); + this.#started = true; + } + move(x, y) { + const newX = Math.round(x); + const newY = Math.round(y); + return this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Pointer, + id: this.#bidiId, + parameters: { + pointerType: "touch" + }, + actions: [ + { + ...this.#properties, + type: ActionType.PointerMove, + x: newX, + y: newY + } + ] + } + ]); + } + async end() { + await this.#page.mainFrame().browsingContext.performActions([ + { + type: SourceActionsType.Pointer, + id: this.#bidiId, + parameters: { + pointerType: "touch" + }, + actions: [ + { + type: ActionType.PointerUp, + button: 0 + } + ] + } + ]); + this.#touchScreen.removeHandle(this); + } +}; +var BidiTouchscreen = class extends Touchscreen { + #page; + constructor(page) { + super(); + this.#page = page; + } + async touchStart(x, y, options = {}) { + const id = this.idGenerator(); + const properties = { + width: 0.5 * 2, + // 2 times default touch radius. + height: 0.5 * 2, + // 2 times default touch radius. + pressure: 0.5, + altitudeAngle: Math.PI / 2 + }; + const touch = new BidiTouchHandle(this.#page, this, id, x, y, properties); + await touch.start(options); + this.touches.push(touch); + return touch; + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Page.js +var __esDecorate10 = 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 __runInitializers10 = 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 __addDisposableResource4 = function(env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env.stack.push({ value, dispose, async }); + } else if (async) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources4 = function(SuppressedError2) { + return function(env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) + throw env.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var BidiPage = (() => { + let _classSuper = Page; + let _trustedEmitter_decorators; + let _trustedEmitter_initializers = []; + let _trustedEmitter_extraInitializers = []; + return class BidiPage2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + _trustedEmitter_decorators = [bubble()]; + __esDecorate10(this, null, _trustedEmitter_decorators, { kind: "accessor", name: "trustedEmitter", static: false, private: false, access: { has: (obj) => "trustedEmitter" in obj, get: (obj) => obj.trustedEmitter, set: (obj, value) => { + obj.trustedEmitter = value; + } }, metadata: _metadata }, _trustedEmitter_initializers, _trustedEmitter_extraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static from(browserContext, browsingContext) { + const page = new BidiPage2(browserContext, browsingContext); + page.#initialize(); + return page; + } + #trustedEmitter_accessor_storage = __runInitializers10(this, _trustedEmitter_initializers, new EventEmitter()); + get trustedEmitter() { + return this.#trustedEmitter_accessor_storage; + } + set trustedEmitter(value) { + this.#trustedEmitter_accessor_storage = value; + } + #browserContext = __runInitializers10(this, _trustedEmitter_extraInitializers); + #frame; + #viewport = null; + #workers = /* @__PURE__ */ new Set(); + keyboard; + mouse; + touchscreen; + tracing; + coverage; + #cdpEmulationManager; + #emulatedNetworkConditions; + _client() { + return this.#frame.client; + } + constructor(browserContext, browsingContext) { + super(); + this.#browserContext = browserContext; + this.#frame = BidiFrame.from(this, browsingContext); + this.#cdpEmulationManager = new EmulationManager(this.#frame.client); + this.tracing = new Tracing(this.#frame.client); + this.coverage = new Coverage(this.#frame.client); + this.keyboard = new BidiKeyboard(this); + this.mouse = new BidiMouse(this); + this.touchscreen = new BidiTouchscreen(this); + } + #initialize() { + this.#frame.browsingContext.on("closed", () => { + this.trustedEmitter.emit("close", void 0); + this.trustedEmitter.removeAllListeners(); + }); + this.trustedEmitter.on("workercreated", (worker) => { + this.#workers.add(worker); + }); + this.trustedEmitter.on("workerdestroyed", (worker) => { + this.#workers.delete(worker); + }); + } + /** + * @internal + */ + _userAgentHeaders = {}; + #userAgentInterception; + #userAgentPreloadScript; + async setUserAgent(userAgent, userAgentMetadata) { + if (!this.#browserContext.browser().cdpSupported && userAgentMetadata) { + throw new UnsupportedOperation("Current Browser does not support `userAgentMetadata`"); + } else if (this.#browserContext.browser().cdpSupported && userAgentMetadata) { + return await this._client().send("Network.setUserAgentOverride", { + userAgent, + userAgentMetadata + }); + } + const enable = userAgent !== ""; + userAgent = userAgent ?? await this.#browserContext.browser().userAgent(); + this._userAgentHeaders = enable ? { + "User-Agent": userAgent + } : {}; + this.#userAgentInterception = await this.#toggleInterception([ + "beforeRequestSent" + /* Bidi.Network.InterceptPhase.BeforeRequestSent */ + ], this.#userAgentInterception, enable); + const changeUserAgent = (userAgent2) => { + Object.defineProperty(navigator, "userAgent", { + value: userAgent2 + }); + }; + const frames = [this.#frame]; + for (const frame of frames) { + frames.push(...frame.childFrames()); + } + if (this.#userAgentPreloadScript) { + await this.removeScriptToEvaluateOnNewDocument(this.#userAgentPreloadScript); + } + const [evaluateToken] = await Promise.all([ + enable ? this.evaluateOnNewDocument(changeUserAgent, userAgent) : void 0, + // When we disable the UserAgent we want to + // evaluate the original value in all Browsing Contexts + frames.map((frame) => { + return frame.evaluate(changeUserAgent, userAgent); + }) + ]); + this.#userAgentPreloadScript = evaluateToken?.identifier; + } + async setBypassCSP(enabled) { + await this._client().send("Page.setBypassCSP", { enabled }); + } + async queryObjects(prototypeHandle) { + assert(!prototypeHandle.disposed, "Prototype JSHandle is disposed!"); + assert(prototypeHandle.id, "Prototype JSHandle must not be referencing primitive value"); + const response = await this.#frame.client.send("Runtime.queryObjects", { + prototypeObjectId: prototypeHandle.id + }); + return this.#frame.mainRealm().createHandle({ + type: "array", + handle: response.objects.objectId + }); + } + browser() { + return this.browserContext().browser(); + } + browserContext() { + return this.#browserContext; + } + mainFrame() { + return this.#frame; + } + async focusedFrame() { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const handle = __addDisposableResource4(env_1, await this.mainFrame().isolatedRealm().evaluateHandle(() => { + let win = window; + while (win.document.activeElement instanceof win.HTMLIFrameElement || win.document.activeElement instanceof win.HTMLFrameElement) { + if (win.document.activeElement.contentWindow === null) { + break; + } + win = win.document.activeElement.contentWindow; + } + return win; + }), false); + const value = handle.remoteValue(); + assert(value.type === "window"); + const frame = this.frames().find((frame2) => { + return frame2._id === value.value.context; + }); + assert(frame); + return frame; + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources4(env_1); + } + } + frames() { + const frames = [this.#frame]; + for (const frame of frames) { + frames.push(...frame.childFrames()); + } + return frames; + } + isClosed() { + return this.#frame.detached; + } + async close(options) { + const env_2 = { stack: [], error: void 0, hasError: false }; + try { + const _guard = __addDisposableResource4(env_2, await this.#browserContext.waitForScreenshotOperations(), false); + try { + await this.#frame.browsingContext.close(options?.runBeforeUnload); + } catch { + return; + } + } catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } finally { + __disposeResources4(env_2); + } + } + async reload(options = {}) { + const [response] = await Promise.all([ + this.#frame.waitForNavigation(options), + this.#frame.browsingContext.reload() + ]).catch(rewriteNavigationError(this.url(), options.timeout ?? this._timeoutSettings.navigationTimeout())); + return response; + } + setDefaultNavigationTimeout(timeout2) { + this._timeoutSettings.setDefaultNavigationTimeout(timeout2); + } + setDefaultTimeout(timeout2) { + this._timeoutSettings.setDefaultTimeout(timeout2); + } + getDefaultTimeout() { + return this._timeoutSettings.timeout(); + } + getDefaultNavigationTimeout() { + return this._timeoutSettings.navigationTimeout(); + } + isJavaScriptEnabled() { + return this.#cdpEmulationManager.javascriptEnabled; + } + async setGeolocation(options) { + return await this.#cdpEmulationManager.setGeolocation(options); + } + async setJavaScriptEnabled(enabled) { + return await this.#cdpEmulationManager.setJavaScriptEnabled(enabled); + } + async emulateMediaType(type) { + return await this.#cdpEmulationManager.emulateMediaType(type); + } + async emulateCPUThrottling(factor) { + return await this.#cdpEmulationManager.emulateCPUThrottling(factor); + } + async emulateMediaFeatures(features) { + return await this.#cdpEmulationManager.emulateMediaFeatures(features); + } + async emulateTimezone(timezoneId) { + return await this.#cdpEmulationManager.emulateTimezone(timezoneId); + } + async emulateIdleState(overrides) { + return await this.#cdpEmulationManager.emulateIdleState(overrides); + } + async emulateVisionDeficiency(type) { + return await this.#cdpEmulationManager.emulateVisionDeficiency(type); + } + async setViewport(viewport) { + if (!this.browser().cdpSupported) { + await this.#frame.browsingContext.setViewport({ + viewport: viewport?.width && viewport?.height ? { + width: viewport.width, + height: viewport.height + } : null, + devicePixelRatio: viewport?.deviceScaleFactor ? viewport.deviceScaleFactor : null + }); + this.#viewport = viewport; + return; + } + const needsReload = await this.#cdpEmulationManager.emulateViewport(viewport); + this.#viewport = viewport; + if (needsReload) { + await this.reload(); + } + } + viewport() { + return this.#viewport; + } + async pdf(options = {}) { + const { timeout: ms = this._timeoutSettings.timeout(), path = void 0 } = options; + const { printBackground: background, margin, landscape, width, height, pageRanges: ranges, scale, preferCSSPageSize } = parsePDFOptions(options, "cm"); + const pageRanges = ranges ? ranges.split(", ") : []; + await firstValueFrom(from(this.mainFrame().isolatedRealm().evaluate(() => { + return document.fonts.ready; + })).pipe(raceWith(timeout(ms)))); + const data = await firstValueFrom(from(this.#frame.browsingContext.print({ + background, + margin, + orientation: landscape ? "landscape" : "portrait", + page: { + width, + height + }, + pageRanges, + scale, + shrinkToFit: !preferCSSPageSize + })).pipe(raceWith(timeout(ms)))); + const typedArray = stringToTypedArray(data, true); + await this._maybeWriteTypedArrayToFile(path, typedArray); + return typedArray; + } + async createPDFStream(options) { + const typedArray = await this.pdf(options); + return new ReadableStream({ + start(controller) { + controller.enqueue(typedArray); + controller.close(); + } + }); + } + async _screenshot(options) { + const { clip, type, captureBeyondViewport, quality } = options; + if (options.omitBackground !== void 0 && options.omitBackground) { + throw new UnsupportedOperation(`BiDi does not support 'omitBackground'.`); + } + if (options.optimizeForSpeed !== void 0 && options.optimizeForSpeed) { + throw new UnsupportedOperation(`BiDi does not support 'optimizeForSpeed'.`); + } + if (options.fromSurface !== void 0 && !options.fromSurface) { + throw new UnsupportedOperation(`BiDi does not support 'fromSurface'.`); + } + if (clip !== void 0 && clip.scale !== void 0 && clip.scale !== 1) { + throw new UnsupportedOperation(`BiDi does not support 'scale' in 'clip'.`); + } + let box; + if (clip) { + if (captureBeyondViewport) { + box = clip; + } else { + const [pageLeft, pageTop] = await this.evaluate(() => { + if (!window.visualViewport) { + throw new Error("window.visualViewport is not supported."); + } + return [ + window.visualViewport.pageLeft, + window.visualViewport.pageTop + ]; + }); + box = { + ...clip, + x: clip.x - pageLeft, + y: clip.y - pageTop + }; + } + } + const data = await this.#frame.browsingContext.captureScreenshot({ + origin: captureBeyondViewport ? "document" : "viewport", + format: { + type: `image/${type}`, + ...quality !== void 0 ? { quality: quality / 100 } : {} + }, + ...box ? { clip: { type: "box", ...box } } : {} + }); + return data; + } + async createCDPSession() { + return await this.#frame.createCDPSession(); + } + async bringToFront() { + await this.#frame.browsingContext.activate(); + } + async evaluateOnNewDocument(pageFunction, ...args) { + const expression = evaluationExpression(pageFunction, ...args); + const script = await this.#frame.browsingContext.addPreloadScript(expression); + return { identifier: script }; + } + async removeScriptToEvaluateOnNewDocument(id) { + await this.#frame.browsingContext.removePreloadScript(id); + } + async exposeFunction(name, pptrFunction) { + return await this.mainFrame().exposeFunction(name, "default" in pptrFunction ? pptrFunction.default : pptrFunction); + } + isDragInterceptionEnabled() { + return false; + } + async setCacheEnabled(enabled) { + if (!this.#browserContext.browser().cdpSupported) { + await this.#frame.browsingContext.setCacheBehavior(enabled ? "default" : "bypass"); + return; + } + await this._client().send("Network.setCacheDisabled", { + cacheDisabled: !enabled + }); + } + async cookies(...urls) { + const normalizedUrls = (urls.length ? urls : [this.url()]).map((url) => { + return new URL(url); + }); + const cookies = await this.#frame.browsingContext.getCookies(); + return cookies.map((cookie) => { + return bidiToPuppeteerCookie(cookie); + }).filter((cookie) => { + return normalizedUrls.some((url) => { + return testUrlMatchCookie(cookie, url); + }); + }); + } + isServiceWorkerBypassed() { + throw new UnsupportedOperation(); + } + target() { + throw new UnsupportedOperation(); + } + waitForFileChooser() { + throw new UnsupportedOperation(); + } + workers() { + return [...this.#workers]; + } + #userInterception; + async setRequestInterception(enable) { + this.#userInterception = await this.#toggleInterception([ + "beforeRequestSent" + /* Bidi.Network.InterceptPhase.BeforeRequestSent */ + ], this.#userInterception, enable); + } + /** + * @internal + */ + _extraHTTPHeaders = {}; + #extraHeadersInterception; + async setExtraHTTPHeaders(headers) { + const extraHTTPHeaders = {}; + for (const [key, value] of Object.entries(headers)) { + assert(isString(value), `Expected value of header "${key}" to be String, but "${typeof value}" is found.`); + extraHTTPHeaders[key.toLowerCase()] = value; + } + this._extraHTTPHeaders = extraHTTPHeaders; + this.#extraHeadersInterception = await this.#toggleInterception([ + "beforeRequestSent" + /* Bidi.Network.InterceptPhase.BeforeRequestSent */ + ], this.#extraHeadersInterception, Boolean(Object.keys(this._extraHTTPHeaders).length)); + } + /** + * @internal + */ + _credentials = null; + #authInterception; + async authenticate(credentials) { + this.#authInterception = await this.#toggleInterception([ + "authRequired" + /* Bidi.Network.InterceptPhase.AuthRequired */ + ], this.#authInterception, Boolean(credentials)); + this._credentials = credentials; + } + async #toggleInterception(phases, interception, expected) { + if (expected && !interception) { + return await this.#frame.browsingContext.addIntercept({ + phases + }); + } else if (!expected && interception) { + await this.#frame.browsingContext.userContext.browser.removeIntercept(interception); + return; + } + return interception; + } + setDragInterception() { + throw new UnsupportedOperation(); + } + setBypassServiceWorker() { + throw new UnsupportedOperation(); + } + async setOfflineMode(enabled) { + if (!this.#browserContext.browser().cdpSupported) { + throw new UnsupportedOperation(); + } + if (!this.#emulatedNetworkConditions) { + this.#emulatedNetworkConditions = { + offline: false, + upload: -1, + download: -1, + latency: 0 + }; + } + this.#emulatedNetworkConditions.offline = enabled; + return await this.#applyNetworkConditions(); + } + async emulateNetworkConditions(networkConditions) { + if (!this.#browserContext.browser().cdpSupported) { + throw new UnsupportedOperation(); + } + if (!this.#emulatedNetworkConditions) { + this.#emulatedNetworkConditions = { + offline: false, + upload: -1, + download: -1, + latency: 0 + }; + } + this.#emulatedNetworkConditions.upload = networkConditions ? networkConditions.upload : -1; + this.#emulatedNetworkConditions.download = networkConditions ? networkConditions.download : -1; + this.#emulatedNetworkConditions.latency = networkConditions ? networkConditions.latency : 0; + return await this.#applyNetworkConditions(); + } + async #applyNetworkConditions() { + if (!this.#emulatedNetworkConditions) { + return; + } + await this._client().send("Network.emulateNetworkConditions", { + offline: this.#emulatedNetworkConditions.offline, + latency: this.#emulatedNetworkConditions.latency, + uploadThroughput: this.#emulatedNetworkConditions.upload, + downloadThroughput: this.#emulatedNetworkConditions.download + }); + } + async setCookie(...cookies) { + const pageURL = this.url(); + const pageUrlStartsWithHTTP = pageURL.startsWith("http"); + for (const cookie of cookies) { + let cookieUrl = cookie.url || ""; + if (!cookieUrl && pageUrlStartsWithHTTP) { + cookieUrl = pageURL; + } + assert(cookieUrl !== "about:blank", `Blank page can not have cookie "${cookie.name}"`); + assert(!String.prototype.startsWith.call(cookieUrl || "", "data:"), `Data URL page can not have cookie "${cookie.name}"`); + const normalizedUrl = URL.canParse(cookieUrl) ? new URL(cookieUrl) : void 0; + const domain = cookie.domain ?? normalizedUrl?.hostname; + assert(domain !== void 0, `At least one of the url and domain needs to be specified`); + const bidiCookie = { + domain, + name: cookie.name, + value: { + type: "string", + value: cookie.value + }, + ...cookie.path !== void 0 ? { path: cookie.path } : {}, + ...cookie.httpOnly !== void 0 ? { httpOnly: cookie.httpOnly } : {}, + ...cookie.secure !== void 0 ? { secure: cookie.secure } : {}, + ...cookie.sameSite !== void 0 ? { sameSite: convertCookiesSameSiteCdpToBiDi(cookie.sameSite) } : {}, + ...cookie.expires !== void 0 ? { expiry: cookie.expires } : {}, + // Chrome-specific properties. + ...cdpSpecificCookiePropertiesFromPuppeteerToBidi(cookie, "sameParty", "sourceScheme", "priority", "url") + }; + if (cookie.partitionKey !== void 0) { + await this.browserContext().userContext.setCookie(bidiCookie, cookie.partitionKey); + } else { + await this.#frame.browsingContext.setCookie(bidiCookie); + } + } + } + async deleteCookie(...cookies) { + await Promise.all(cookies.map(async (deleteCookieRequest) => { + const cookieUrl = deleteCookieRequest.url ?? this.url(); + const normalizedUrl = URL.canParse(cookieUrl) ? new URL(cookieUrl) : void 0; + const domain = deleteCookieRequest.domain ?? normalizedUrl?.hostname; + assert(domain !== void 0, `At least one of the url and domain needs to be specified`); + const filter2 = { + domain, + name: deleteCookieRequest.name, + ...deleteCookieRequest.path !== void 0 ? { path: deleteCookieRequest.path } : {} + }; + await this.#frame.browsingContext.deleteCookie(filter2); + })); + } + async removeExposedFunction(name) { + await this.#frame.removeExposedFunction(name); + } + metrics() { + throw new UnsupportedOperation(); + } + async goBack(options = {}) { + return await this.#go(-1, options); + } + async goForward(options = {}) { + return await this.#go(1, options); + } + async #go(delta, options) { + const controller = new AbortController(); + try { + const [response] = await Promise.all([ + this.waitForNavigation({ + ...options, + signal: controller.signal + }), + this.#frame.browsingContext.traverseHistory(delta) + ]); + return response; + } catch (error) { + controller.abort(); + if (isErrorLike(error)) { + if (error.message.includes("no such history entry")) { + return null; + } + } + throw error; + } + } + waitForDevicePrompt() { + throw new UnsupportedOperation(); + } + }; +})(); +function evaluationExpression(fun, ...args) { + return `() => {${evaluationString(fun, ...args)}}`; +} +function testUrlMatchCookieHostname(cookie, normalizedUrl) { + const cookieDomain = cookie.domain.toLowerCase(); + const urlHostname = normalizedUrl.hostname.toLowerCase(); + if (cookieDomain === urlHostname) { + return true; + } + return cookieDomain.startsWith(".") && urlHostname.endsWith(cookieDomain); +} +function testUrlMatchCookiePath(cookie, normalizedUrl) { + const uriPath = normalizedUrl.pathname; + const cookiePath = cookie.path; + if (uriPath === cookiePath) { + return true; + } + if (uriPath.startsWith(cookiePath)) { + if (cookiePath.endsWith("/")) { + return true; + } + if (uriPath[cookiePath.length] === "/") { + return true; + } + } + return false; +} +function testUrlMatchCookie(cookie, url) { + const normalizedUrl = new URL(url); + assert(cookie !== void 0); + if (!testUrlMatchCookieHostname(cookie, normalizedUrl)) { + return false; + } + return testUrlMatchCookiePath(cookie, normalizedUrl); +} +function bidiToPuppeteerCookie(bidiCookie) { + const partitionKey = bidiCookie[CDP_SPECIFIC_PREFIX + "partitionKey"]; + function getParitionKey() { + if (typeof partitionKey === "string") { + return { partitionKey }; + } + if (typeof partitionKey === "object" && partitionKey !== null) { + return { + // TODO: a breaking change in Puppeteer is required to change + // partitionKey type and report the composite partition key. + partitionKey: partitionKey.topLevelSite + }; + } + return {}; + } + return { + name: bidiCookie.name, + // Presents binary value as base64 string. + value: bidiCookie.value.value, + domain: bidiCookie.domain, + path: bidiCookie.path, + size: bidiCookie.size, + httpOnly: bidiCookie.httpOnly, + secure: bidiCookie.secure, + sameSite: convertCookiesSameSiteBiDiToCdp(bidiCookie.sameSite), + expires: bidiCookie.expiry ?? -1, + session: bidiCookie.expiry === void 0 || bidiCookie.expiry <= 0, + // Extending with CDP-specific properties with `goog:` prefix. + ...cdpSpecificCookiePropertiesFromBidiToPuppeteer(bidiCookie, "sameParty", "sourceScheme", "partitionKeyOpaque", "priority"), + ...getParitionKey() + }; +} +var CDP_SPECIFIC_PREFIX = "goog:"; +function cdpSpecificCookiePropertiesFromBidiToPuppeteer(bidiCookie, ...propertyNames) { + const result = {}; + for (const property of propertyNames) { + if (bidiCookie[CDP_SPECIFIC_PREFIX + property] !== void 0) { + result[property] = bidiCookie[CDP_SPECIFIC_PREFIX + property]; + } + } + return result; +} +function cdpSpecificCookiePropertiesFromPuppeteerToBidi(cookieParam, ...propertyNames) { + const result = {}; + for (const property of propertyNames) { + if (cookieParam[property] !== void 0) { + result[CDP_SPECIFIC_PREFIX + property] = cookieParam[property]; + } + } + return result; +} +function convertCookiesSameSiteBiDiToCdp(sameSite) { + return sameSite === "strict" ? "Strict" : sameSite === "lax" ? "Lax" : "None"; +} +function convertCookiesSameSiteCdpToBiDi(sameSite) { + return sameSite === "Strict" ? "strict" : sameSite === "Lax" ? "lax" : "none"; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Target.js +init_cjs_shim(); +var BidiBrowserTarget = class extends Target { + #browser; + constructor(browser) { + super(); + this.#browser = browser; + } + asPage() { + throw new UnsupportedOperation(); + } + url() { + return ""; + } + createCDPSession() { + throw new UnsupportedOperation(); + } + type() { + return TargetType.BROWSER; + } + browser() { + return this.#browser; + } + browserContext() { + return this.#browser.defaultBrowserContext(); + } + opener() { + throw new UnsupportedOperation(); + } +}; +var BidiPageTarget = class extends Target { + #page; + constructor(page) { + super(); + this.#page = page; + } + async page() { + return this.#page; + } + async asPage() { + return BidiPage.from(this.browserContext(), this.#page.mainFrame().browsingContext); + } + url() { + return this.#page.url(); + } + createCDPSession() { + return this.#page.createCDPSession(); + } + type() { + return TargetType.PAGE; + } + browser() { + return this.browserContext().browser(); + } + browserContext() { + return this.#page.browserContext(); + } + opener() { + throw new UnsupportedOperation(); + } +}; +var BidiFrameTarget = class extends Target { + #frame; + #page; + constructor(frame) { + super(); + this.#frame = frame; + } + async page() { + if (this.#page === void 0) { + this.#page = BidiPage.from(this.browserContext(), this.#frame.browsingContext); + } + return this.#page; + } + async asPage() { + return BidiPage.from(this.browserContext(), this.#frame.browsingContext); + } + url() { + return this.#frame.url(); + } + createCDPSession() { + return this.#frame.createCDPSession(); + } + type() { + return TargetType.PAGE; + } + browser() { + return this.browserContext().browser(); + } + browserContext() { + return this.#frame.page().browserContext(); + } + opener() { + throw new UnsupportedOperation(); + } +}; +var BidiWorkerTarget = class extends Target { + #worker; + constructor(worker) { + super(); + this.#worker = worker; + } + async page() { + throw new UnsupportedOperation(); + } + async asPage() { + throw new UnsupportedOperation(); + } + url() { + return this.#worker.url(); + } + createCDPSession() { + throw new UnsupportedOperation(); + } + type() { + return TargetType.OTHER; + } + browser() { + return this.browserContext().browser(); + } + browserContext() { + return this.#worker.frame.page().browserContext(); + } + opener() { + throw new UnsupportedOperation(); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/BrowserContext.js +var __esDecorate11 = 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 __runInitializers11 = 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 __addDisposableResource5 = function(env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env.stack.push({ value, dispose, async }); + } else if (async) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources5 = function(SuppressedError2) { + return function(env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) + throw env.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var BidiBrowserContext = (() => { + let _classSuper = BrowserContext; + let _trustedEmitter_decorators; + let _trustedEmitter_initializers = []; + let _trustedEmitter_extraInitializers = []; + return class BidiBrowserContext2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + _trustedEmitter_decorators = [bubble()]; + __esDecorate11(this, null, _trustedEmitter_decorators, { kind: "accessor", name: "trustedEmitter", static: false, private: false, access: { has: (obj) => "trustedEmitter" in obj, get: (obj) => obj.trustedEmitter, set: (obj, value) => { + obj.trustedEmitter = value; + } }, metadata: _metadata }, _trustedEmitter_initializers, _trustedEmitter_extraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static from(browser, userContext, options) { + const context = new BidiBrowserContext2(browser, userContext, options); + context.#initialize(); + return context; + } + #trustedEmitter_accessor_storage = __runInitializers11(this, _trustedEmitter_initializers, new EventEmitter()); + get trustedEmitter() { + return this.#trustedEmitter_accessor_storage; + } + set trustedEmitter(value) { + this.#trustedEmitter_accessor_storage = value; + } + #browser = __runInitializers11(this, _trustedEmitter_extraInitializers); + #defaultViewport; + // This is public because of cookies. + userContext; + #pages = /* @__PURE__ */ new WeakMap(); + #targets = /* @__PURE__ */ new Map(); + #overrides = []; + constructor(browser, userContext, options) { + super(); + this.#browser = browser; + this.userContext = userContext; + this.#defaultViewport = options.defaultViewport; + } + #initialize() { + for (const browsingContext of this.userContext.browsingContexts) { + this.#createPage(browsingContext); + } + this.userContext.on("browsingcontext", ({ browsingContext }) => { + const page = this.#createPage(browsingContext); + browsingContext.once("DOMContentLoaded", () => { + if (browsingContext.originalOpener) { + for (const context of this.userContext.browsingContexts) { + if (context.id === browsingContext.originalOpener) { + this.#pages.get(context).trustedEmitter.emit("popup", page); + } + } + } + }); + }); + this.userContext.on("closed", () => { + this.trustedEmitter.removeAllListeners(); + }); + } + #createPage(browsingContext) { + const page = BidiPage.from(this, browsingContext); + this.#pages.set(browsingContext, page); + page.trustedEmitter.on("close", () => { + this.#pages.delete(browsingContext); + }); + const pageTarget = new BidiPageTarget(page); + const pageTargets = /* @__PURE__ */ new Map(); + this.#targets.set(page, [pageTarget, pageTargets]); + page.trustedEmitter.on("frameattached", (frame) => { + const bidiFrame = frame; + const target = new BidiFrameTarget(bidiFrame); + pageTargets.set(bidiFrame, target); + this.trustedEmitter.emit("targetcreated", target); + }); + page.trustedEmitter.on("framenavigated", (frame) => { + const bidiFrame = frame; + const target = pageTargets.get(bidiFrame); + if (target === void 0) { + this.trustedEmitter.emit("targetchanged", pageTarget); + } else { + this.trustedEmitter.emit("targetchanged", target); + } + }); + page.trustedEmitter.on("framedetached", (frame) => { + const bidiFrame = frame; + const target = pageTargets.get(bidiFrame); + if (target === void 0) { + return; + } + pageTargets.delete(bidiFrame); + this.trustedEmitter.emit("targetdestroyed", target); + }); + page.trustedEmitter.on("workercreated", (worker) => { + const bidiWorker = worker; + const target = new BidiWorkerTarget(bidiWorker); + pageTargets.set(bidiWorker, target); + this.trustedEmitter.emit("targetcreated", target); + }); + page.trustedEmitter.on("workerdestroyed", (worker) => { + const bidiWorker = worker; + const target = pageTargets.get(bidiWorker); + if (target === void 0) { + return; + } + pageTargets.delete(worker); + this.trustedEmitter.emit("targetdestroyed", target); + }); + page.trustedEmitter.on("close", () => { + this.#targets.delete(page); + this.trustedEmitter.emit("targetdestroyed", pageTarget); + }); + this.trustedEmitter.emit("targetcreated", pageTarget); + return page; + } + targets() { + return [...this.#targets.values()].flatMap(([target, frames]) => { + return [target, ...frames.values()]; + }); + } + async newPage() { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const _guard = __addDisposableResource5(env_1, await this.waitForScreenshotOperations(), false); + const context = await this.userContext.createBrowsingContext( + "tab" + /* Bidi.BrowsingContext.CreateType.Tab */ + ); + const page = this.#pages.get(context); + if (!page) { + throw new Error("Page is not found"); + } + if (this.#defaultViewport) { + try { + await page.setViewport(this.#defaultViewport); + } catch { + } + } + return page; + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources5(env_1); + } + } + async close() { + assert(this.userContext.id !== UserContext.DEFAULT, "Default BrowserContext cannot be closed!"); + try { + await this.userContext.remove(); + } catch (error) { + debugError(error); + } + this.#targets.clear(); + } + browser() { + return this.#browser; + } + async pages() { + return [...this.userContext.browsingContexts].map((context) => { + return this.#pages.get(context); + }); + } + async overridePermissions(origin, permissions) { + const permissionsSet = new Set(permissions.map((permission) => { + const protocolPermission = WEB_PERMISSION_TO_PROTOCOL_PERMISSION.get(permission); + if (!protocolPermission) { + throw new Error("Unknown permission: " + permission); + } + return permission; + })); + await Promise.all(Array.from(WEB_PERMISSION_TO_PROTOCOL_PERMISSION.keys()).map((permission) => { + const result = this.userContext.setPermissions( + origin, + { + name: permission + }, + permissionsSet.has(permission) ? "granted" : "denied" + /* Bidi.Permissions.PermissionState.Denied */ + ); + this.#overrides.push({ origin, permission }); + if (!permissionsSet.has(permission)) { + return result.catch(debugError); + } + return result; + })); + } + async clearPermissionOverrides() { + const promises = this.#overrides.map(({ permission, origin }) => { + return this.userContext.setPermissions( + origin, + { + name: permission + }, + "prompt" + /* Bidi.Permissions.PermissionState.Prompt */ + ).catch(debugError); + }); + this.#overrides = []; + await Promise.all(promises); + } + get id() { + if (this.userContext.id === UserContext.DEFAULT) { + return void 0; + } + return this.userContext.id; + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/core/Session.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/core/Browser.js +init_cjs_shim(); +var __runInitializers12 = 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 __esDecorate12 = 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 __addDisposableResource6 = function(env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env.stack.push({ value, dispose, async }); + } else if (async) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources6 = function(SuppressedError2) { + return function(env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) + throw env.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var Browser2 = (() => { + let _classSuper = EventEmitter; + let _instanceExtraInitializers = []; + let _dispose_decorators; + let _close_decorators; + let _addPreloadScript_decorators; + let _removeIntercept_decorators; + let _removePreloadScript_decorators; + let _createUserContext_decorators; + return class Browser3 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + __esDecorate12(this, null, _dispose_decorators, { kind: "method", name: "dispose", static: false, private: false, access: { has: (obj) => "dispose" in obj, get: (obj) => obj.dispose }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate12(this, null, _close_decorators, { kind: "method", name: "close", static: false, private: false, access: { has: (obj) => "close" in obj, get: (obj) => obj.close }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate12(this, null, _addPreloadScript_decorators, { kind: "method", name: "addPreloadScript", static: false, private: false, access: { has: (obj) => "addPreloadScript" in obj, get: (obj) => obj.addPreloadScript }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate12(this, null, _removeIntercept_decorators, { kind: "method", name: "removeIntercept", static: false, private: false, access: { has: (obj) => "removeIntercept" in obj, get: (obj) => obj.removeIntercept }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate12(this, null, _removePreloadScript_decorators, { kind: "method", name: "removePreloadScript", static: false, private: false, access: { has: (obj) => "removePreloadScript" in obj, get: (obj) => obj.removePreloadScript }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate12(this, null, _createUserContext_decorators, { kind: "method", name: "createUserContext", static: false, private: false, access: { has: (obj) => "createUserContext" in obj, get: (obj) => obj.createUserContext }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static async from(session) { + const browser = new Browser3(session); + await browser.#initialize(); + return browser; + } + #closed = (__runInitializers12(this, _instanceExtraInitializers), false); + #reason; + #disposables = new DisposableStack(); + #userContexts = /* @__PURE__ */ new Map(); + session; + #sharedWorkers = /* @__PURE__ */ new Map(); + constructor(session) { + super(); + this.session = session; + } + async #initialize() { + const sessionEmitter = this.#disposables.use(new EventEmitter(this.session)); + sessionEmitter.once("ended", ({ reason }) => { + this.dispose(reason); + }); + sessionEmitter.on("script.realmCreated", (info) => { + if (info.type !== "shared-worker") { + return; + } + this.#sharedWorkers.set(info.realm, SharedWorkerRealm.from(this, info.realm, info.origin)); + }); + await this.#syncUserContexts(); + await this.#syncBrowsingContexts(); + } + async #syncUserContexts() { + const { result: { userContexts } } = await this.session.send("browser.getUserContexts", {}); + for (const context of userContexts) { + this.#createUserContext(context.userContext); + } + } + async #syncBrowsingContexts() { + const contextIds = /* @__PURE__ */ new Set(); + let contexts; + { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const sessionEmitter = __addDisposableResource6(env_1, new EventEmitter(this.session), false); + sessionEmitter.on("browsingContext.contextCreated", (info) => { + contextIds.add(info.context); + }); + const { result } = await this.session.send("browsingContext.getTree", {}); + contexts = result.contexts; + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources6(env_1); + } + } + for (const info of contexts) { + if (!contextIds.has(info.context)) { + this.session.emit("browsingContext.contextCreated", info); + } + if (info.children) { + contexts.push(...info.children); + } + } + } + #createUserContext(id) { + const userContext = UserContext.create(this, id); + this.#userContexts.set(userContext.id, userContext); + const userContextEmitter = this.#disposables.use(new EventEmitter(userContext)); + userContextEmitter.once("closed", () => { + userContextEmitter.removeAllListeners(); + this.#userContexts.delete(userContext.id); + }); + return userContext; + } + get closed() { + return this.#closed; + } + get defaultUserContext() { + return this.#userContexts.get(UserContext.DEFAULT); + } + get disconnected() { + return this.#reason !== void 0; + } + get disposed() { + return this.disconnected; + } + get userContexts() { + return this.#userContexts.values(); + } + dispose(reason, closed = false) { + this.#closed = closed; + this.#reason = reason; + this[disposeSymbol](); + } + async close() { + try { + await this.session.send("browser.close", {}); + } finally { + this.dispose("Browser already closed.", true); + } + } + async addPreloadScript(functionDeclaration, options = {}) { + const { result: { script } } = await this.session.send("script.addPreloadScript", { + functionDeclaration, + ...options, + contexts: options.contexts?.map((context) => { + return context.id; + }) + }); + return script; + } + async removeIntercept(intercept) { + await this.session.send("network.removeIntercept", { + intercept + }); + } + async removePreloadScript(script) { + await this.session.send("script.removePreloadScript", { + script + }); + } + async createUserContext() { + const { result: { userContext: context } } = await this.session.send("browser.createUserContext", {}); + return this.#createUserContext(context); + } + [(_dispose_decorators = [inertIfDisposed], _close_decorators = [throwIfDisposed((browser) => { + return browser.#reason; + })], _addPreloadScript_decorators = [throwIfDisposed((browser) => { + return browser.#reason; + })], _removeIntercept_decorators = [throwIfDisposed((browser) => { + return browser.#reason; + })], _removePreloadScript_decorators = [throwIfDisposed((browser) => { + return browser.#reason; + })], _createUserContext_decorators = [throwIfDisposed((browser) => { + return browser.#reason; + })], disposeSymbol)]() { + this.#reason ??= "Browser was disconnected, probably because the session ended."; + if (this.closed) { + this.emit("closed", { reason: this.#reason }); + } + this.emit("disconnected", { reason: this.#reason }); + this.#disposables.dispose(); + super[disposeSymbol](); + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/core/Session.js +var __runInitializers13 = 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 __esDecorate13 = 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 Session = (() => { + let _classSuper = EventEmitter; + let _instanceExtraInitializers = []; + let _connection_decorators; + let _connection_initializers = []; + let _connection_extraInitializers = []; + let _dispose_decorators; + let _send_decorators; + let _subscribe_decorators; + let _addIntercepts_decorators; + let _end_decorators; + return class Session2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + __esDecorate13(this, null, _connection_decorators, { kind: "accessor", name: "connection", static: false, private: false, access: { has: (obj) => "connection" in obj, get: (obj) => obj.connection, set: (obj, value) => { + obj.connection = value; + } }, metadata: _metadata }, _connection_initializers, _connection_extraInitializers); + __esDecorate13(this, null, _dispose_decorators, { kind: "method", name: "dispose", static: false, private: false, access: { has: (obj) => "dispose" in obj, get: (obj) => obj.dispose }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate13(this, null, _send_decorators, { kind: "method", name: "send", static: false, private: false, access: { has: (obj) => "send" in obj, get: (obj) => obj.send }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate13(this, null, _subscribe_decorators, { kind: "method", name: "subscribe", static: false, private: false, access: { has: (obj) => "subscribe" in obj, get: (obj) => obj.subscribe }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate13(this, null, _addIntercepts_decorators, { kind: "method", name: "addIntercepts", static: false, private: false, access: { has: (obj) => "addIntercepts" in obj, get: (obj) => obj.addIntercepts }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate13(this, null, _end_decorators, { kind: "method", name: "end", static: false, private: false, access: { has: (obj) => "end" in obj, get: (obj) => obj.end }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + static async from(connection, capabilities) { + const { result } = await connection.send("session.new", { + capabilities + }); + const session = new Session2(connection, result); + await session.#initialize(); + return session; + } + #reason = __runInitializers13(this, _instanceExtraInitializers); + #disposables = new DisposableStack(); + #info; + browser; + #connection_accessor_storage = __runInitializers13(this, _connection_initializers, void 0); + get connection() { + return this.#connection_accessor_storage; + } + set connection(value) { + this.#connection_accessor_storage = value; + } + constructor(connection, info) { + super(); + __runInitializers13(this, _connection_extraInitializers); + this.#info = info; + this.connection = connection; + } + async #initialize() { + this.browser = await Browser2.from(this); + const browserEmitter = this.#disposables.use(this.browser); + browserEmitter.once("closed", ({ reason }) => { + this.dispose(reason); + }); + const seen = /* @__PURE__ */ new WeakSet(); + this.on("browsingContext.fragmentNavigated", (info) => { + if (seen.has(info)) { + return; + } + seen.add(info); + this.emit("browsingContext.navigationStarted", info); + this.emit("browsingContext.fragmentNavigated", info); + }); + } + get capabilities() { + return this.#info.capabilities; + } + get disposed() { + return this.ended; + } + get ended() { + return this.#reason !== void 0; + } + get id() { + return this.#info.sessionId; + } + dispose(reason) { + this.#reason = reason; + this[disposeSymbol](); + } + /** + * Currently, there is a 1:1 relationship between the session and the + * session. In the future, we might support multiple sessions and in that + * case we always needs to make sure that the session for the right session + * object is used, so we implement this method here, although it's not defined + * in the spec. + */ + async send(method, params) { + return await this.connection.send(method, params); + } + async subscribe(events, contexts) { + await this.send("session.subscribe", { + events, + contexts + }); + } + async addIntercepts(events, contexts) { + await this.send("session.subscribe", { + events, + contexts + }); + } + async end() { + try { + await this.send("session.end", {}); + } finally { + this.dispose(`Session already ended.`); + } + } + [(_connection_decorators = [bubble()], _dispose_decorators = [inertIfDisposed], _send_decorators = [throwIfDisposed((session) => { + return session.#reason; + })], _subscribe_decorators = [throwIfDisposed((session) => { + return session.#reason; + })], _addIntercepts_decorators = [throwIfDisposed((session) => { + return session.#reason; + })], _end_decorators = [throwIfDisposed((session) => { + return session.#reason; + })], disposeSymbol)]() { + this.#reason ??= "Session already destroyed, probably because the connection broke."; + this.emit("ended", { reason: this.#reason }); + this.#disposables.dispose(); + super[disposeSymbol](); + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/Browser.js +var __esDecorate14 = 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 __runInitializers14 = 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 __setFunctionName2 = 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 }); +}; +var BidiBrowser = (() => { + let _classSuper = Browser; + let _private_trustedEmitter_decorators; + let _private_trustedEmitter_initializers = []; + let _private_trustedEmitter_extraInitializers = []; + let _private_trustedEmitter_descriptor; + return class BidiBrowser2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + _private_trustedEmitter_decorators = [bubble()]; + __esDecorate14(this, _private_trustedEmitter_descriptor = { get: __setFunctionName2(function() { + return this.#trustedEmitter_accessor_storage; + }, "#trustedEmitter", "get"), set: __setFunctionName2(function(value) { + this.#trustedEmitter_accessor_storage = value; + }, "#trustedEmitter", "set") }, _private_trustedEmitter_decorators, { kind: "accessor", name: "#trustedEmitter", static: false, private: true, access: { has: (obj) => #trustedEmitter in obj, get: (obj) => obj.#trustedEmitter, set: (obj, value) => { + obj.#trustedEmitter = value; + } }, metadata: _metadata }, _private_trustedEmitter_initializers, _private_trustedEmitter_extraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + protocol = "webDriverBiDi"; + static subscribeModules = [ + "browsingContext", + "network", + "log", + "script" + ]; + static subscribeCdpEvents = [ + // Coverage + "cdp.Debugger.scriptParsed", + "cdp.CSS.styleSheetAdded", + "cdp.Runtime.executionContextsCleared", + // Tracing + "cdp.Tracing.tracingComplete", + // TODO: subscribe to all CDP events in the future. + "cdp.Network.requestWillBeSent", + "cdp.Debugger.scriptParsed", + "cdp.Page.screencastFrame" + ]; + static async create(opts) { + const session = await Session.from(opts.connection, { + firstMatch: opts.capabilities?.firstMatch, + alwaysMatch: { + ...opts.capabilities?.alwaysMatch, + // Capabilities that come from Puppeteer's API take precedence. + acceptInsecureCerts: opts.acceptInsecureCerts, + unhandledPromptBehavior: { + default: "ignore" + }, + webSocketUrl: true, + // Puppeteer with WebDriver BiDi does not support prerendering + // yet because WebDriver BiDi behavior is not specified. See + // https://github.com/w3c/webdriver-bidi/issues/321. + "goog:prerenderingDisabled": true + } + }); + await session.subscribe(session.capabilities.browserName.toLocaleLowerCase().includes("firefox") ? BidiBrowser2.subscribeModules : [...BidiBrowser2.subscribeModules, ...BidiBrowser2.subscribeCdpEvents]); + const browser = new BidiBrowser2(session.browser, opts); + browser.#initialize(); + return browser; + } + #trustedEmitter_accessor_storage = __runInitializers14(this, _private_trustedEmitter_initializers, new EventEmitter()); + get #trustedEmitter() { + return _private_trustedEmitter_descriptor.get.call(this); + } + set #trustedEmitter(value) { + return _private_trustedEmitter_descriptor.set.call(this, value); + } + #process = __runInitializers14(this, _private_trustedEmitter_extraInitializers); + #closeCallback; + #browserCore; + #defaultViewport; + #browserContexts = /* @__PURE__ */ new WeakMap(); + #target = new BidiBrowserTarget(this); + #cdpConnection; + constructor(browserCore, opts) { + super(); + this.#process = opts.process; + this.#closeCallback = opts.closeCallback; + this.#browserCore = browserCore; + this.#defaultViewport = opts.defaultViewport; + this.#cdpConnection = opts.cdpConnection; + } + #initialize() { + for (const userContext of this.#browserCore.userContexts) { + this.#createBrowserContext(userContext); + } + this.#browserCore.once("disconnected", () => { + this.#trustedEmitter.emit("disconnected", void 0); + this.#trustedEmitter.removeAllListeners(); + }); + this.#process?.once("close", () => { + this.#browserCore.dispose("Browser process exited.", true); + this.connection.dispose(); + }); + } + get #browserName() { + return this.#browserCore.session.capabilities.browserName; + } + get #browserVersion() { + return this.#browserCore.session.capabilities.browserVersion; + } + get cdpSupported() { + return this.#cdpConnection !== void 0; + } + get cdpConnection() { + return this.#cdpConnection; + } + async userAgent() { + return this.#browserCore.session.capabilities.userAgent; + } + #createBrowserContext(userContext) { + const browserContext = BidiBrowserContext.from(this, userContext, { + defaultViewport: this.#defaultViewport + }); + this.#browserContexts.set(userContext, browserContext); + browserContext.trustedEmitter.on("targetcreated", (target) => { + this.#trustedEmitter.emit("targetcreated", target); + }); + browserContext.trustedEmitter.on("targetchanged", (target) => { + this.#trustedEmitter.emit("targetchanged", target); + }); + browserContext.trustedEmitter.on("targetdestroyed", (target) => { + this.#trustedEmitter.emit("targetdestroyed", target); + }); + return browserContext; + } + get connection() { + return this.#browserCore.session.connection; + } + wsEndpoint() { + return this.connection.url; + } + async close() { + if (this.connection.closed) { + return; + } + try { + await this.#browserCore.close(); + await this.#closeCallback?.call(null); + } catch (error) { + debugError(error); + } finally { + this.connection.dispose(); + } + } + get connected() { + return !this.#browserCore.disconnected; + } + process() { + return this.#process ?? null; + } + async createBrowserContext(_options) { + const userContext = await this.#browserCore.createUserContext(); + return this.#createBrowserContext(userContext); + } + async version() { + return `${this.#browserName}/${this.#browserVersion}`; + } + browserContexts() { + return [...this.#browserCore.userContexts].map((context) => { + return this.#browserContexts.get(context); + }); + } + defaultBrowserContext() { + return this.#browserContexts.get(this.#browserCore.defaultUserContext); + } + newPage() { + return this.defaultBrowserContext().newPage(); + } + targets() { + return [ + this.#target, + ...this.browserContexts().flatMap((context) => { + return context.targets(); + }) + ]; + } + target() { + return this.#target; + } + async disconnect() { + try { + await this.#browserCore.session.end(); + } catch (error) { + debugError(error); + } finally { + this.connection.dispose(); + } + } + get debugInfo() { + return { + pendingProtocolErrors: this.connection.getPendingProtocolErrors() + }; + } + }; +})(); +export { + BidiBrowser, + BidiBrowserContext, + BidiConnection, + BidiElementHandle, + BidiFrame, + BidiFrameRealm, + BidiHTTPRequest, + BidiHTTPResponse, + BidiJSHandle, + BidiKeyboard, + BidiMouse, + BidiPage, + BidiRealm, + BidiTouchscreen, + BidiWorkerRealm, + connectBidiOverCdp, + requests +}; +/*! Bundled license information: + +puppeteer-core/lib/esm/puppeteer/bidi/Connection.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/BidiOverCdp.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/core/Navigation.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/core/Realm.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/core/Request.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/core/UserPrompt.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/core/BrowsingContext.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/core/UserContext.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/Deserializer.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/Dialog.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/JSHandle.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/ElementHandle.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/ExposedFunction.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/Serializer.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/util.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/WebWorker.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/Frame.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/Input.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/Page.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/Target.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/BrowserContext.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/core/Browser.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/core/Session.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/Browser.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/bidi.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) +*/ diff --git a/docs/node/chunk-CTKBT5JH.mjs b/docs/node/chunk-CTKBT5JH.mjs new file mode 100644 index 00000000..77eade2a --- /dev/null +++ b/docs/node/chunk-CTKBT5JH.mjs @@ -0,0 +1,46 @@ +import { createRequire } from 'module';const require = createRequire(import.meta.url); +import { + init_cjs_shim +} from "./chunk-THMF2HPO.mjs"; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/BrowserWebSocketTransport.js +init_cjs_shim(); +var BrowserWebSocketTransport = class { + static create(url) { + return new Promise((resolve, reject) => { + const ws = new WebSocket(url); + ws.addEventListener("open", () => { + return resolve(new BrowserWebSocketTransport(ws)); + }); + ws.addEventListener("error", reject); + }); + } + #ws; + onmessage; + onclose; + constructor(ws) { + this.#ws = ws; + this.#ws.addEventListener("message", (event) => { + if (this.onmessage) { + this.onmessage.call(null, event.data); + } + }); + this.#ws.addEventListener("close", () => { + if (this.onclose) { + this.onclose.call(null); + } + }); + this.#ws.addEventListener("error", () => { + }); + } + send(message) { + this.#ws.send(message); + } + close() { + this.#ws.close(); + } +}; + +export { + BrowserWebSocketTransport +}; diff --git a/docs/node/chunk-FLSG3ZVV.mjs b/docs/node/chunk-FLSG3ZVV.mjs new file mode 100644 index 00000000..2c596f1c --- /dev/null +++ b/docs/node/chunk-FLSG3ZVV.mjs @@ -0,0 +1,760 @@ +import { createRequire } from 'module';const require = createRequire(import.meta.url); +import { + __commonJS, + __require, + init_cjs_shim +} from "./chunk-THMF2HPO.mjs"; + +// ../testeranto/node_modules/ms/index.js +var require_ms = __commonJS({ + "../testeranto/node_modules/ms/index.js"(exports, module) { + init_cjs_shim(); + var s = 1e3; + var m = s * 60; + var h = m * 60; + var d = h * 24; + var w = d * 7; + var y = d * 365.25; + module.exports = function(val, options) { + options = options || {}; + var type = typeof val; + if (type === "string" && val.length > 0) { + return parse(val); + } else if (type === "number" && isFinite(val)) { + return options.long ? fmtLong(val) : fmtShort(val); + } + throw new Error( + "val is not a non-empty string or a valid number. val=" + JSON.stringify(val) + ); + }; + function parse(str) { + str = String(str); + if (str.length > 100) { + return; + } + var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec( + str + ); + if (!match) { + return; + } + var n = parseFloat(match[1]); + var type = (match[2] || "ms").toLowerCase(); + switch (type) { + case "years": + case "year": + case "yrs": + case "yr": + case "y": + return n * y; + case "weeks": + case "week": + case "w": + return n * w; + case "days": + case "day": + case "d": + return n * d; + case "hours": + case "hour": + case "hrs": + case "hr": + case "h": + return n * h; + case "minutes": + case "minute": + case "mins": + case "min": + case "m": + return n * m; + case "seconds": + case "second": + case "secs": + case "sec": + case "s": + return n * s; + case "milliseconds": + case "millisecond": + case "msecs": + case "msec": + case "ms": + return n; + default: + return void 0; + } + } + function fmtShort(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return Math.round(ms / d) + "d"; + } + if (msAbs >= h) { + return Math.round(ms / h) + "h"; + } + if (msAbs >= m) { + return Math.round(ms / m) + "m"; + } + if (msAbs >= s) { + return Math.round(ms / s) + "s"; + } + return ms + "ms"; + } + function fmtLong(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return plural(ms, msAbs, d, "day"); + } + if (msAbs >= h) { + return plural(ms, msAbs, h, "hour"); + } + if (msAbs >= m) { + return plural(ms, msAbs, m, "minute"); + } + if (msAbs >= s) { + return plural(ms, msAbs, s, "second"); + } + return ms + " ms"; + } + function plural(ms, msAbs, n, name) { + var isPlural = msAbs >= n * 1.5; + return Math.round(ms / n) + " " + name + (isPlural ? "s" : ""); + } + } +}); + +// ../testeranto/node_modules/debug/src/common.js +var require_common = __commonJS({ + "../testeranto/node_modules/debug/src/common.js"(exports, module) { + init_cjs_shim(); + function setup(env) { + createDebug.debug = createDebug; + createDebug.default = createDebug; + createDebug.coerce = coerce; + createDebug.disable = disable; + createDebug.enable = enable; + createDebug.enabled = enabled; + createDebug.humanize = require_ms(); + createDebug.destroy = destroy; + Object.keys(env).forEach((key) => { + createDebug[key] = env[key]; + }); + createDebug.names = []; + createDebug.skips = []; + createDebug.formatters = {}; + function selectColor(namespace) { + let hash = 0; + for (let i = 0; i < namespace.length; i++) { + hash = (hash << 5) - hash + namespace.charCodeAt(i); + hash |= 0; + } + return createDebug.colors[Math.abs(hash) % createDebug.colors.length]; + } + createDebug.selectColor = selectColor; + function createDebug(namespace) { + let prevTime; + let enableOverride = null; + let namespacesCache; + let enabledCache; + function debug(...args) { + if (!debug.enabled) { + return; + } + const self = debug; + const curr = Number(/* @__PURE__ */ new Date()); + const ms = curr - (prevTime || curr); + self.diff = ms; + self.prev = prevTime; + self.curr = curr; + prevTime = curr; + args[0] = createDebug.coerce(args[0]); + if (typeof args[0] !== "string") { + args.unshift("%O"); + } + let index = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => { + if (match === "%%") { + return "%"; + } + index++; + const formatter = createDebug.formatters[format]; + if (typeof formatter === "function") { + const val = args[index]; + match = formatter.call(self, val); + args.splice(index, 1); + index--; + } + return match; + }); + createDebug.formatArgs.call(self, args); + const logFn = self.log || createDebug.log; + logFn.apply(self, args); + } + debug.namespace = namespace; + debug.useColors = createDebug.useColors(); + debug.color = createDebug.selectColor(namespace); + debug.extend = extend; + debug.destroy = createDebug.destroy; + Object.defineProperty(debug, "enabled", { + enumerable: true, + configurable: false, + get: () => { + if (enableOverride !== null) { + return enableOverride; + } + if (namespacesCache !== createDebug.namespaces) { + namespacesCache = createDebug.namespaces; + enabledCache = createDebug.enabled(namespace); + } + return enabledCache; + }, + set: (v) => { + enableOverride = v; + } + }); + if (typeof createDebug.init === "function") { + createDebug.init(debug); + } + return debug; + } + function extend(namespace, delimiter) { + const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace); + newDebug.log = this.log; + return newDebug; + } + function enable(namespaces) { + createDebug.save(namespaces); + createDebug.namespaces = namespaces; + createDebug.names = []; + createDebug.skips = []; + let i; + const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/); + const len = split.length; + for (i = 0; i < len; i++) { + if (!split[i]) { + continue; + } + namespaces = split[i].replace(/\*/g, ".*?"); + if (namespaces[0] === "-") { + createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$")); + } else { + createDebug.names.push(new RegExp("^" + namespaces + "$")); + } + } + } + function disable() { + const namespaces = [ + ...createDebug.names.map(toNamespace), + ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace) + ].join(","); + createDebug.enable(""); + return namespaces; + } + function enabled(name) { + if (name[name.length - 1] === "*") { + return true; + } + let i; + let len; + for (i = 0, len = createDebug.skips.length; i < len; i++) { + if (createDebug.skips[i].test(name)) { + return false; + } + } + for (i = 0, len = createDebug.names.length; i < len; i++) { + if (createDebug.names[i].test(name)) { + return true; + } + } + return false; + } + function toNamespace(regexp) { + return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*"); + } + function coerce(val) { + if (val instanceof Error) { + return val.stack || val.message; + } + return val; + } + function destroy() { + console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); + } + createDebug.enable(createDebug.load()); + return createDebug; + } + module.exports = setup; + } +}); + +// ../testeranto/node_modules/debug/src/browser.js +var require_browser = __commonJS({ + "../testeranto/node_modules/debug/src/browser.js"(exports, module) { + init_cjs_shim(); + exports.formatArgs = formatArgs; + exports.save = save; + exports.load = load; + exports.useColors = useColors; + exports.storage = localstorage(); + exports.destroy = (() => { + let warned = false; + return () => { + if (!warned) { + warned = true; + console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); + } + }; + })(); + exports.colors = [ + "#0000CC", + "#0000FF", + "#0033CC", + "#0033FF", + "#0066CC", + "#0066FF", + "#0099CC", + "#0099FF", + "#00CC00", + "#00CC33", + "#00CC66", + "#00CC99", + "#00CCCC", + "#00CCFF", + "#3300CC", + "#3300FF", + "#3333CC", + "#3333FF", + "#3366CC", + "#3366FF", + "#3399CC", + "#3399FF", + "#33CC00", + "#33CC33", + "#33CC66", + "#33CC99", + "#33CCCC", + "#33CCFF", + "#6600CC", + "#6600FF", + "#6633CC", + "#6633FF", + "#66CC00", + "#66CC33", + "#9900CC", + "#9900FF", + "#9933CC", + "#9933FF", + "#99CC00", + "#99CC33", + "#CC0000", + "#CC0033", + "#CC0066", + "#CC0099", + "#CC00CC", + "#CC00FF", + "#CC3300", + "#CC3333", + "#CC3366", + "#CC3399", + "#CC33CC", + "#CC33FF", + "#CC6600", + "#CC6633", + "#CC9900", + "#CC9933", + "#CCCC00", + "#CCCC33", + "#FF0000", + "#FF0033", + "#FF0066", + "#FF0099", + "#FF00CC", + "#FF00FF", + "#FF3300", + "#FF3333", + "#FF3366", + "#FF3399", + "#FF33CC", + "#FF33FF", + "#FF6600", + "#FF6633", + "#FF9900", + "#FF9933", + "#FFCC00", + "#FFCC33" + ]; + function useColors() { + if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) { + return true; + } + if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { + return false; + } + let m; + return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773 + typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker + typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/); + } + function formatArgs(args) { + args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff); + if (!this.useColors) { + return; + } + const c = "color: " + this.color; + args.splice(1, 0, c, "color: inherit"); + let index = 0; + let lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, (match) => { + if (match === "%%") { + return; + } + index++; + if (match === "%c") { + lastC = index; + } + }); + args.splice(lastC, 0, c); + } + exports.log = console.debug || console.log || (() => { + }); + function save(namespaces) { + try { + if (namespaces) { + exports.storage.setItem("debug", namespaces); + } else { + exports.storage.removeItem("debug"); + } + } catch (error) { + } + } + function load() { + let r; + try { + r = exports.storage.getItem("debug"); + } catch (error) { + } + if (!r && typeof process !== "undefined" && "env" in process) { + r = process.env.DEBUG; + } + return r; + } + function localstorage() { + try { + return localStorage; + } catch (error) { + } + } + module.exports = require_common()(exports); + var { formatters } = module.exports; + formatters.j = function(v) { + try { + return JSON.stringify(v); + } catch (error) { + return "[UnexpectedJSONParseError]: " + error.message; + } + }; + } +}); + +// ../testeranto/node_modules/has-flag/index.js +var require_has_flag = __commonJS({ + "../testeranto/node_modules/has-flag/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + module.exports = (flag, argv) => { + argv = argv || process.argv; + const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--"; + const pos = argv.indexOf(prefix + flag); + const terminatorPos = argv.indexOf("--"); + return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos); + }; + } +}); + +// ../testeranto/node_modules/supports-color/index.js +var require_supports_color = __commonJS({ + "../testeranto/node_modules/supports-color/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var os = __require("os"); + var hasFlag = require_has_flag(); + var env = process.env; + var forceColor; + if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false")) { + forceColor = false; + } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) { + forceColor = true; + } + if ("FORCE_COLOR" in env) { + forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0; + } + function translateLevel(level) { + if (level === 0) { + return false; + } + return { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3 + }; + } + function supportsColor(stream) { + if (forceColor === false) { + return 0; + } + if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) { + return 3; + } + if (hasFlag("color=256")) { + return 2; + } + if (stream && !stream.isTTY && forceColor !== true) { + return 0; + } + const min = forceColor ? 1 : 0; + if (process.platform === "win32") { + const osRelease = os.release().split("."); + if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) { + return Number(osRelease[2]) >= 14931 ? 3 : 2; + } + return 1; + } + if ("CI" in env) { + if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some((sign) => sign in env) || env.CI_NAME === "codeship") { + return 1; + } + return min; + } + if ("TEAMCITY_VERSION" in env) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; + } + if (env.COLORTERM === "truecolor") { + return 3; + } + if ("TERM_PROGRAM" in env) { + const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10); + switch (env.TERM_PROGRAM) { + case "iTerm.app": + return version >= 3 ? 3 : 2; + case "Apple_Terminal": + return 2; + } + } + if (/-256(color)?$/i.test(env.TERM)) { + return 2; + } + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { + return 1; + } + if ("COLORTERM" in env) { + return 1; + } + if (env.TERM === "dumb") { + return min; + } + return min; + } + function getSupportLevel(stream) { + const level = supportsColor(stream); + return translateLevel(level); + } + module.exports = { + supportsColor: getSupportLevel, + stdout: getSupportLevel(process.stdout), + stderr: getSupportLevel(process.stderr) + }; + } +}); + +// ../testeranto/node_modules/debug/src/node.js +var require_node = __commonJS({ + "../testeranto/node_modules/debug/src/node.js"(exports, module) { + init_cjs_shim(); + var tty = __require("tty"); + var util = __require("util"); + exports.init = init; + exports.log = log; + exports.formatArgs = formatArgs; + exports.save = save; + exports.load = load; + exports.useColors = useColors; + exports.destroy = util.deprecate( + () => { + }, + "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`." + ); + exports.colors = [6, 2, 3, 4, 5, 1]; + try { + const supportsColor = require_supports_color(); + if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) { + exports.colors = [ + 20, + 21, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 56, + 57, + 62, + 63, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 92, + 93, + 98, + 99, + 112, + 113, + 128, + 129, + 134, + 135, + 148, + 149, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 178, + 179, + 184, + 185, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 214, + 215, + 220, + 221 + ]; + } + } catch (error) { + } + exports.inspectOpts = Object.keys(process.env).filter((key) => { + return /^debug_/i.test(key); + }).reduce((obj, key) => { + const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => { + return k.toUpperCase(); + }); + let val = process.env[key]; + if (/^(yes|on|true|enabled)$/i.test(val)) { + val = true; + } else if (/^(no|off|false|disabled)$/i.test(val)) { + val = false; + } else if (val === "null") { + val = null; + } else { + val = Number(val); + } + obj[prop] = val; + return obj; + }, {}); + function useColors() { + return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd); + } + function formatArgs(args) { + const { namespace: name, useColors: useColors2 } = this; + if (useColors2) { + const c = this.color; + const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c); + const prefix = ` ${colorCode};1m${name} \x1B[0m`; + args[0] = prefix + args[0].split("\n").join("\n" + prefix); + args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m"); + } else { + args[0] = getDate() + name + " " + args[0]; + } + } + function getDate() { + if (exports.inspectOpts.hideDate) { + return ""; + } + return (/* @__PURE__ */ new Date()).toISOString() + " "; + } + function log(...args) { + return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n"); + } + function save(namespaces) { + if (namespaces) { + process.env.DEBUG = namespaces; + } else { + delete process.env.DEBUG; + } + } + function load() { + return process.env.DEBUG; + } + function init(debug) { + debug.inspectOpts = {}; + const keys = Object.keys(exports.inspectOpts); + for (let i = 0; i < keys.length; i++) { + debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]]; + } + } + module.exports = require_common()(exports); + var { formatters } = module.exports; + formatters.o = function(v) { + this.inspectOpts.colors = this.useColors; + return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" "); + }; + formatters.O = function(v) { + this.inspectOpts.colors = this.useColors; + return util.inspect(v, this.inspectOpts); + }; + } +}); + +// ../testeranto/node_modules/debug/src/index.js +var require_src = __commonJS({ + "../testeranto/node_modules/debug/src/index.js"(exports, module) { + init_cjs_shim(); + if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) { + module.exports = require_browser(); + } else { + module.exports = require_node(); + } + } +}); + +export { + require_src +}; diff --git a/docs/node/chunk-L7PQJBZK.mjs b/docs/node/chunk-L7PQJBZK.mjs new file mode 100644 index 00000000..6848ad6c --- /dev/null +++ b/docs/node/chunk-L7PQJBZK.mjs @@ -0,0 +1,59470 @@ +import { createRequire } from 'module';const require = createRequire(import.meta.url); +import { + require_src +} from "./chunk-FLSG3ZVV.mjs"; +import { + ARIAQueryHandler, + Accessibility, + AsyncDisposableStack, + AsyncIterableUtil, + Browser, + BrowserContext, + CDPSession, + CDPSessionEvent, + CallbackRegistry, + ConsoleMessage, + Coverage, + DEFAULT_VIEWPORT, + Deferred, + Dialog, + DisposableStack, + ElementHandle, + EmulationManager, + EventEmitter, + Frame, + FrameEvent, + HTTPRequest, + HTTPResponse, + JSHandle, + Keyboard, + LazyArg, + Mouse, + MouseButton, + Mutex, + Page, + ProtocolError, + PuppeteerURL, + Realm, + SOURCE_URL_REGEX, + STATUS_TEXTS, + SecurityDetails, + Target, + TargetCloseError, + TargetType, + TimeoutError, + TimeoutSettings, + TouchError, + Touchscreen, + Tracing, + UTILITY_WORLD_NAME, + UnsupportedOperation, + WEB_PERMISSION_TO_PROTOCOL_PERMISSION, + WebWorker, + assert, + asyncDisposeSymbol, + bindIsolatedHandle, + bufferCount, + concatMap, + createProtocolErrorMessage, + customQueryHandlers, + debug, + debugError, + disposeSymbol, + environment, + evaluationString, + filter, + firstValueFrom, + from, + fromEmitterEvent, + fromEvent, + getReadableAsTypedArray, + getReadableFromProtocolStream, + getSourcePuppeteerURLIfAvailable, + getSourceUrlComment, + guarded, + handleError, + headersArray, + isErrorLike, + isNode, + isString, + lastValueFrom, + map, + parsePDFOptions, + race, + raceWith, + scriptInjector, + stringToBase64, + stringToTypedArray, + stringifyFunction, + takeUntil, + tap, + throwIfDetached, + throwIfDisposed, + timeout, + timer, + validateDialogType, + withSourcePuppeteerURLIfNone +} from "./chunk-RBWPBMY4.mjs"; +import { + NodeWebSocketTransport +} from "./chunk-PJC2V65J.mjs"; +import { + __commonJS, + __esm, + __export, + __publicField, + __require, + __toCommonJS, + __toESM, + init_cjs_shim +} from "./chunk-THMF2HPO.mjs"; + +// node_modules/assertion-error/index.js +var require_assertion_error = __commonJS({ + "node_modules/assertion-error/index.js"(exports, module) { + init_cjs_shim(); + function exclude() { + var excludes = [].slice.call(arguments); + function excludeProps(res, obj) { + Object.keys(obj).forEach(function(key) { + if (!~excludes.indexOf(key)) + res[key] = obj[key]; + }); + } + return function extendExclude() { + var args = [].slice.call(arguments), i = 0, res = {}; + for (; i < args.length; i++) { + excludeProps(res, args[i]); + } + return res; + }; + } + module.exports = AssertionError2; + function AssertionError2(message, _props, ssf) { + var extend = exclude("name", "message", "stack", "constructor", "toJSON"), props = extend(_props || {}); + this.message = message || "Unspecified AssertionError"; + this.showDiff = false; + for (var key in props) { + this[key] = props[key]; + } + ssf = ssf || AssertionError2; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, ssf); + } else { + try { + throw new Error(); + } catch (e) { + this.stack = e.stack; + } + } + } + AssertionError2.prototype = Object.create(Error.prototype); + AssertionError2.prototype.name = "AssertionError"; + AssertionError2.prototype.constructor = AssertionError2; + AssertionError2.prototype.toJSON = function(stack) { + var extend = exclude("constructor", "toJSON", "stack"), props = extend({ name: this.name }, this); + if (false !== stack && this.stack) { + props.stack = this.stack; + } + return props; + }; + } +}); + +// node_modules/pathval/index.js +var require_pathval = __commonJS({ + "node_modules/pathval/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + function hasProperty(obj, name) { + if (typeof obj === "undefined" || obj === null) { + return false; + } + return name in Object(obj); + } + function parsePath(path10) { + var str = path10.replace(/([^\\])\[/g, "$1.["); + var parts = str.match(/(\\\.|[^.]+?)+/g); + return parts.map(function mapMatches(value) { + if (value === "constructor" || value === "__proto__" || value === "prototype") { + return {}; + } + var regexp = /^\[(\d+)\]$/; + var mArr = regexp.exec(value); + var parsed = null; + if (mArr) { + parsed = { i: parseFloat(mArr[1]) }; + } else { + parsed = { p: value.replace(/\\([.[\]])/g, "$1") }; + } + return parsed; + }); + } + function internalGetPathValue(obj, parsed, pathDepth) { + var temporaryValue = obj; + var res = null; + pathDepth = typeof pathDepth === "undefined" ? parsed.length : pathDepth; + for (var i = 0; i < pathDepth; i++) { + var part = parsed[i]; + if (temporaryValue) { + if (typeof part.p === "undefined") { + temporaryValue = temporaryValue[part.i]; + } else { + temporaryValue = temporaryValue[part.p]; + } + if (i === pathDepth - 1) { + res = temporaryValue; + } + } + } + return res; + } + function internalSetPathValue(obj, val, parsed) { + var tempObj = obj; + var pathDepth = parsed.length; + var part = null; + for (var i = 0; i < pathDepth; i++) { + var propName = null; + var propVal = null; + part = parsed[i]; + if (i === pathDepth - 1) { + propName = typeof part.p === "undefined" ? part.i : part.p; + tempObj[propName] = val; + } else if (typeof part.p !== "undefined" && tempObj[part.p]) { + tempObj = tempObj[part.p]; + } else if (typeof part.i !== "undefined" && tempObj[part.i]) { + tempObj = tempObj[part.i]; + } else { + var next = parsed[i + 1]; + propName = typeof part.p === "undefined" ? part.i : part.p; + propVal = typeof next.p === "undefined" ? [] : {}; + tempObj[propName] = propVal; + tempObj = tempObj[propName]; + } + } + } + function getPathInfo(obj, path10) { + var parsed = parsePath(path10); + var last = parsed[parsed.length - 1]; + var info = { + parent: parsed.length > 1 ? internalGetPathValue(obj, parsed, parsed.length - 1) : obj, + name: last.p || last.i, + value: internalGetPathValue(obj, parsed) + }; + info.exists = hasProperty(info.parent, info.name); + return info; + } + function getPathValue(obj, path10) { + var info = getPathInfo(obj, path10); + return info.value; + } + function setPathValue(obj, path10, val) { + var parsed = parsePath(path10); + internalSetPathValue(obj, val, parsed); + return obj; + } + module.exports = { + hasProperty, + getPathInfo, + getPathValue, + setPathValue + }; + } +}); + +// node_modules/chai/lib/chai/utils/flag.js +var require_flag = __commonJS({ + "node_modules/chai/lib/chai/utils/flag.js"(exports, module) { + init_cjs_shim(); + module.exports = function flag(obj, key, value) { + var flags = obj.__flags || (obj.__flags = /* @__PURE__ */ Object.create(null)); + if (arguments.length === 3) { + flags[key] = value; + } else { + return flags[key]; + } + }; + } +}); + +// node_modules/chai/lib/chai/utils/test.js +var require_test = __commonJS({ + "node_modules/chai/lib/chai/utils/test.js"(exports, module) { + init_cjs_shim(); + var flag = require_flag(); + module.exports = function test(obj, args) { + var negate = flag(obj, "negate"), expr = args[0]; + return negate ? !expr : expr; + }; + } +}); + +// node_modules/type-detect/type-detect.js +var require_type_detect = __commonJS({ + "node_modules/type-detect/type-detect.js"(exports, module) { + init_cjs_shim(); + (function(global2, factory) { + typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, global2.typeDetect = factory()); + })(exports, function() { + "use strict"; + var promiseExists = typeof Promise === "function"; + var globalObject = function(Obj) { + if (typeof globalThis === "object") { + return globalThis; + } + Object.defineProperty(Obj, "typeDetectGlobalObject", { + get: function get() { + return this; + }, + configurable: true + }); + var global2 = typeDetectGlobalObject; + delete Obj.typeDetectGlobalObject; + return global2; + }(Object.prototype); + var symbolExists = typeof Symbol !== "undefined"; + var mapExists = typeof Map !== "undefined"; + var setExists = typeof Set !== "undefined"; + var weakMapExists = typeof WeakMap !== "undefined"; + var weakSetExists = typeof WeakSet !== "undefined"; + var dataViewExists = typeof DataView !== "undefined"; + var symbolIteratorExists = symbolExists && typeof Symbol.iterator !== "undefined"; + var symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== "undefined"; + var setEntriesExists = setExists && typeof Set.prototype.entries === "function"; + var mapEntriesExists = mapExists && typeof Map.prototype.entries === "function"; + var setIteratorPrototype = setEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Set()).entries()); + var mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Map()).entries()); + var arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === "function"; + var arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]()); + var stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === "function"; + var stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(""[Symbol.iterator]()); + var toStringLeftSliceLength = 8; + var toStringRightSliceLength = -1; + function typeDetect(obj) { + var typeofObj = typeof obj; + if (typeofObj !== "object") { + return typeofObj; + } + if (obj === null) { + return "null"; + } + if (obj === globalObject) { + return "global"; + } + if (Array.isArray(obj) && (symbolToStringTagExists === false || !(Symbol.toStringTag in obj))) { + return "Array"; + } + if (typeof window === "object" && window !== null) { + if (typeof window.location === "object" && obj === window.location) { + return "Location"; + } + if (typeof window.document === "object" && obj === window.document) { + return "Document"; + } + if (typeof window.navigator === "object") { + if (typeof window.navigator.mimeTypes === "object" && obj === window.navigator.mimeTypes) { + return "MimeTypeArray"; + } + if (typeof window.navigator.plugins === "object" && obj === window.navigator.plugins) { + return "PluginArray"; + } + } + if ((typeof window.HTMLElement === "function" || typeof window.HTMLElement === "object") && obj instanceof window.HTMLElement) { + if (obj.tagName === "BLOCKQUOTE") { + return "HTMLQuoteElement"; + } + if (obj.tagName === "TD") { + return "HTMLTableDataCellElement"; + } + if (obj.tagName === "TH") { + return "HTMLTableHeaderCellElement"; + } + } + } + var stringTag = symbolToStringTagExists && obj[Symbol.toStringTag]; + if (typeof stringTag === "string") { + return stringTag; + } + var objPrototype = Object.getPrototypeOf(obj); + if (objPrototype === RegExp.prototype) { + return "RegExp"; + } + if (objPrototype === Date.prototype) { + return "Date"; + } + if (promiseExists && objPrototype === Promise.prototype) { + return "Promise"; + } + if (setExists && objPrototype === Set.prototype) { + return "Set"; + } + if (mapExists && objPrototype === Map.prototype) { + return "Map"; + } + if (weakSetExists && objPrototype === WeakSet.prototype) { + return "WeakSet"; + } + if (weakMapExists && objPrototype === WeakMap.prototype) { + return "WeakMap"; + } + if (dataViewExists && objPrototype === DataView.prototype) { + return "DataView"; + } + if (mapExists && objPrototype === mapIteratorPrototype) { + return "Map Iterator"; + } + if (setExists && objPrototype === setIteratorPrototype) { + return "Set Iterator"; + } + if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) { + return "Array Iterator"; + } + if (stringIteratorExists && objPrototype === stringIteratorPrototype) { + return "String Iterator"; + } + if (objPrototype === null) { + return "Object"; + } + return Object.prototype.toString.call(obj).slice(toStringLeftSliceLength, toStringRightSliceLength); + } + return typeDetect; + }); + } +}); + +// node_modules/chai/lib/chai/utils/expectTypes.js +var require_expectTypes = __commonJS({ + "node_modules/chai/lib/chai/utils/expectTypes.js"(exports, module) { + init_cjs_shim(); + var AssertionError2 = require_assertion_error(); + var flag = require_flag(); + var type = require_type_detect(); + module.exports = function expectTypes(obj, types) { + var flagMsg = flag(obj, "message"); + var ssfi = flag(obj, "ssfi"); + flagMsg = flagMsg ? flagMsg + ": " : ""; + obj = flag(obj, "object"); + types = types.map(function(t) { + return t.toLowerCase(); + }); + types.sort(); + var str = types.map(function(t, index) { + var art = ~["a", "e", "i", "o", "u"].indexOf(t.charAt(0)) ? "an" : "a"; + var or = types.length > 1 && index === types.length - 1 ? "or " : ""; + return or + art + " " + t; + }).join(", "); + var objType = type(obj).toLowerCase(); + if (!types.some(function(expected) { + return objType === expected; + })) { + throw new AssertionError2( + flagMsg + "object tested must be " + str + ", but " + objType + " given", + void 0, + ssfi + ); + } + }; + } +}); + +// node_modules/chai/lib/chai/utils/getActual.js +var require_getActual = __commonJS({ + "node_modules/chai/lib/chai/utils/getActual.js"(exports, module) { + init_cjs_shim(); + module.exports = function getActual(obj, args) { + return args.length > 4 ? args[4] : obj._obj; + }; + } +}); + +// node_modules/get-func-name/index.js +var require_get_func_name = __commonJS({ + "node_modules/get-func-name/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var toString = Function.prototype.toString; + var functionNameMatch = /\s*function(?:\s|\s*\/\*[^(?:*\/)]+\*\/\s*)*([^\s\(\/]+)/; + var maxFunctionSourceLength = 512; + function getFuncName(aFunc) { + if (typeof aFunc !== "function") { + return null; + } + var name = ""; + if (typeof Function.prototype.name === "undefined" && typeof aFunc.name === "undefined") { + var functionSource = toString.call(aFunc); + if (functionSource.indexOf("(") > maxFunctionSourceLength) { + return name; + } + var match = functionSource.match(functionNameMatch); + if (match) { + name = match[1]; + } + } else { + name = aFunc.name; + } + return name; + } + module.exports = getFuncName; + } +}); + +// node_modules/loupe/loupe.js +var require_loupe = __commonJS({ + "node_modules/loupe/loupe.js"(exports, module) { + init_cjs_shim(); + (function(global2, factory) { + typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.loupe = {})); + })(exports, function(exports2) { + "use strict"; + function _typeof(obj) { + "@babel/helpers - typeof"; + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function(obj2) { + return typeof obj2; + }; + } else { + _typeof = function(obj2) { + return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2; + }; + } + return _typeof(obj); + } + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) + return arr; + } + function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) + return; + var _arr = []; + var _n = true; + var _d = false; + var _e = void 0; + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + if (i && _arr.length === i) + break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) + _i["return"](); + } finally { + if (_d) + throw _e; + } + } + return _arr; + } + function _unsupportedIterableToArray(o, minLen) { + if (!o) + return; + if (typeof o === "string") + return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) + n = o.constructor.name; + if (n === "Map" || n === "Set") + return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) + return _arrayLikeToArray(o, minLen); + } + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) + len = arr.length; + for (var i = 0, arr2 = new Array(len); i < len; i++) + arr2[i] = arr[i]; + return arr2; + } + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + var ansiColors = { + bold: ["1", "22"], + dim: ["2", "22"], + italic: ["3", "23"], + underline: ["4", "24"], + // 5 & 6 are blinking + inverse: ["7", "27"], + hidden: ["8", "28"], + strike: ["9", "29"], + // 10-20 are fonts + // 21-29 are resets for 1-9 + black: ["30", "39"], + red: ["31", "39"], + green: ["32", "39"], + yellow: ["33", "39"], + blue: ["34", "39"], + magenta: ["35", "39"], + cyan: ["36", "39"], + white: ["37", "39"], + brightblack: ["30;1", "39"], + brightred: ["31;1", "39"], + brightgreen: ["32;1", "39"], + brightyellow: ["33;1", "39"], + brightblue: ["34;1", "39"], + brightmagenta: ["35;1", "39"], + brightcyan: ["36;1", "39"], + brightwhite: ["37;1", "39"], + grey: ["90", "39"] + }; + var styles = { + special: "cyan", + number: "yellow", + bigint: "yellow", + boolean: "yellow", + undefined: "grey", + null: "bold", + string: "green", + symbol: "green", + date: "magenta", + regexp: "red" + }; + var truncator = "\u2026"; + function colorise(value, styleType) { + var color = ansiColors[styles[styleType]] || ansiColors[styleType]; + if (!color) { + return String(value); + } + return "\x1B[".concat(color[0], "m").concat(String(value), "\x1B[").concat(color[1], "m"); + } + function normaliseOptions() { + var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref$showHidden = _ref.showHidden, showHidden = _ref$showHidden === void 0 ? false : _ref$showHidden, _ref$depth = _ref.depth, depth = _ref$depth === void 0 ? 2 : _ref$depth, _ref$colors = _ref.colors, colors = _ref$colors === void 0 ? false : _ref$colors, _ref$customInspect = _ref.customInspect, customInspect = _ref$customInspect === void 0 ? true : _ref$customInspect, _ref$showProxy = _ref.showProxy, showProxy = _ref$showProxy === void 0 ? false : _ref$showProxy, _ref$maxArrayLength = _ref.maxArrayLength, maxArrayLength = _ref$maxArrayLength === void 0 ? Infinity : _ref$maxArrayLength, _ref$breakLength = _ref.breakLength, breakLength = _ref$breakLength === void 0 ? Infinity : _ref$breakLength, _ref$seen = _ref.seen, seen = _ref$seen === void 0 ? [] : _ref$seen, _ref$truncate = _ref.truncate, truncate2 = _ref$truncate === void 0 ? Infinity : _ref$truncate, _ref$stylize = _ref.stylize, stylize = _ref$stylize === void 0 ? String : _ref$stylize; + var options = { + showHidden: Boolean(showHidden), + depth: Number(depth), + colors: Boolean(colors), + customInspect: Boolean(customInspect), + showProxy: Boolean(showProxy), + maxArrayLength: Number(maxArrayLength), + breakLength: Number(breakLength), + truncate: Number(truncate2), + seen, + stylize + }; + if (options.colors) { + options.stylize = colorise; + } + return options; + } + function truncate(string, length) { + var tail = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : truncator; + string = String(string); + var tailLength = tail.length; + var stringLength = string.length; + if (tailLength > length && stringLength > tailLength) { + return tail; + } + if (stringLength > length && stringLength > tailLength) { + return "".concat(string.slice(0, length - tailLength)).concat(tail); + } + return string; + } + function inspectList(list, options, inspectItem) { + var separator = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : ", "; + inspectItem = inspectItem || options.inspect; + var size = list.length; + if (size === 0) + return ""; + var originalLength = options.truncate; + var output = ""; + var peek = ""; + var truncated = ""; + for (var i = 0; i < size; i += 1) { + var last = i + 1 === list.length; + var secondToLast = i + 2 === list.length; + truncated = "".concat(truncator, "(").concat(list.length - i, ")"); + var value = list[i]; + options.truncate = originalLength - output.length - (last ? 0 : separator.length); + var string = peek || inspectItem(value, options) + (last ? "" : separator); + var nextLength = output.length + string.length; + var truncatedLength = nextLength + truncated.length; + if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) { + break; + } + if (!last && !secondToLast && truncatedLength > originalLength) { + break; + } + peek = last ? "" : inspectItem(list[i + 1], options) + (secondToLast ? "" : separator); + if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) { + break; + } + output += string; + if (!last && !secondToLast && nextLength + peek.length >= originalLength) { + truncated = "".concat(truncator, "(").concat(list.length - i - 1, ")"); + break; + } + truncated = ""; + } + return "".concat(output).concat(truncated); + } + function quoteComplexKey(key) { + if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) { + return key; + } + return JSON.stringify(key).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"); + } + function inspectProperty(_ref2, options) { + var _ref3 = _slicedToArray(_ref2, 2), key = _ref3[0], value = _ref3[1]; + options.truncate -= 2; + if (typeof key === "string") { + key = quoteComplexKey(key); + } else if (typeof key !== "number") { + key = "[".concat(options.inspect(key, options), "]"); + } + options.truncate -= key.length; + value = options.inspect(value, options); + return "".concat(key, ": ").concat(value); + } + function inspectArray(array, options) { + var nonIndexProperties = Object.keys(array).slice(array.length); + if (!array.length && !nonIndexProperties.length) + return "[]"; + options.truncate -= 4; + var listContents = inspectList(array, options); + options.truncate -= listContents.length; + var propertyContents = ""; + if (nonIndexProperties.length) { + propertyContents = inspectList(nonIndexProperties.map(function(key) { + return [key, array[key]]; + }), options, inspectProperty); + } + return "[ ".concat(listContents).concat(propertyContents ? ", ".concat(propertyContents) : "", " ]"); + } + var toString = Function.prototype.toString; + var functionNameMatch = /\s*function(?:\s|\s*\/\*[^(?:*\/)]+\*\/\s*)*([^\s\(\/]+)/; + var maxFunctionSourceLength = 512; + function getFuncName(aFunc) { + if (typeof aFunc !== "function") { + return null; + } + var name = ""; + if (typeof Function.prototype.name === "undefined" && typeof aFunc.name === "undefined") { + var functionSource = toString.call(aFunc); + if (functionSource.indexOf("(") > maxFunctionSourceLength) { + return name; + } + var match = functionSource.match(functionNameMatch); + if (match) { + name = match[1]; + } + } else { + name = aFunc.name; + } + return name; + } + var getFuncName_1 = getFuncName; + var getArrayName = function getArrayName2(array) { + if (typeof Buffer === "function" && array instanceof Buffer) { + return "Buffer"; + } + if (array[Symbol.toStringTag]) { + return array[Symbol.toStringTag]; + } + return getFuncName_1(array.constructor); + }; + function inspectTypedArray(array, options) { + var name = getArrayName(array); + options.truncate -= name.length + 4; + var nonIndexProperties = Object.keys(array).slice(array.length); + if (!array.length && !nonIndexProperties.length) + return "".concat(name, "[]"); + var output = ""; + for (var i = 0; i < array.length; i++) { + var string = "".concat(options.stylize(truncate(array[i], options.truncate), "number")).concat(i === array.length - 1 ? "" : ", "); + options.truncate -= string.length; + if (array[i] !== array.length && options.truncate <= 3) { + output += "".concat(truncator, "(").concat(array.length - array[i] + 1, ")"); + break; + } + output += string; + } + var propertyContents = ""; + if (nonIndexProperties.length) { + propertyContents = inspectList(nonIndexProperties.map(function(key) { + return [key, array[key]]; + }), options, inspectProperty); + } + return "".concat(name, "[ ").concat(output).concat(propertyContents ? ", ".concat(propertyContents) : "", " ]"); + } + function inspectDate(dateObject, options) { + var stringRepresentation = dateObject.toJSON(); + if (stringRepresentation === null) { + return "Invalid Date"; + } + var split = stringRepresentation.split("T"); + var date = split[0]; + return options.stylize("".concat(date, "T").concat(truncate(split[1], options.truncate - date.length - 1)), "date"); + } + function inspectFunction(func, options) { + var name = getFuncName_1(func); + if (!name) { + return options.stylize("[Function]", "special"); + } + return options.stylize("[Function ".concat(truncate(name, options.truncate - 11), "]"), "special"); + } + function inspectMapEntry(_ref, options) { + var _ref2 = _slicedToArray(_ref, 2), key = _ref2[0], value = _ref2[1]; + options.truncate -= 4; + key = options.inspect(key, options); + options.truncate -= key.length; + value = options.inspect(value, options); + return "".concat(key, " => ").concat(value); + } + function mapToEntries(map2) { + var entries = []; + map2.forEach(function(value, key) { + entries.push([key, value]); + }); + return entries; + } + function inspectMap(map2, options) { + var size = map2.size - 1; + if (size <= 0) { + return "Map{}"; + } + options.truncate -= 7; + return "Map{ ".concat(inspectList(mapToEntries(map2), options, inspectMapEntry), " }"); + } + var isNaN2 = Number.isNaN || function(i) { + return i !== i; + }; + function inspectNumber(number, options) { + if (isNaN2(number)) { + return options.stylize("NaN", "number"); + } + if (number === Infinity) { + return options.stylize("Infinity", "number"); + } + if (number === -Infinity) { + return options.stylize("-Infinity", "number"); + } + if (number === 0) { + return options.stylize(1 / number === Infinity ? "+0" : "-0", "number"); + } + return options.stylize(truncate(number, options.truncate), "number"); + } + function inspectBigInt(number, options) { + var nums = truncate(number.toString(), options.truncate - 1); + if (nums !== truncator) + nums += "n"; + return options.stylize(nums, "bigint"); + } + function inspectRegExp(value, options) { + var flags = value.toString().split("/")[2]; + var sourceLength = options.truncate - (2 + flags.length); + var source = value.source; + return options.stylize("/".concat(truncate(source, sourceLength), "/").concat(flags), "regexp"); + } + function arrayFromSet(set) { + var values = []; + set.forEach(function(value) { + values.push(value); + }); + return values; + } + function inspectSet(set, options) { + if (set.size === 0) + return "Set{}"; + options.truncate -= 7; + return "Set{ ".concat(inspectList(arrayFromSet(set), options), " }"); + } + var stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g"); + var escapeCharacters = { + "\b": "\\b", + " ": "\\t", + "\n": "\\n", + "\f": "\\f", + "\r": "\\r", + "'": "\\'", + "\\": "\\\\" + }; + var hex = 16; + var unicodeLength = 4; + function escape(char) { + return escapeCharacters[char] || "\\u".concat("0000".concat(char.charCodeAt(0).toString(hex)).slice(-unicodeLength)); + } + function inspectString(string, options) { + if (stringEscapeChars.test(string)) { + string = string.replace(stringEscapeChars, escape); + } + return options.stylize("'".concat(truncate(string, options.truncate - 2), "'"), "string"); + } + function inspectSymbol(value) { + if ("description" in Symbol.prototype) { + return value.description ? "Symbol(".concat(value.description, ")") : "Symbol()"; + } + return value.toString(); + } + var getPromiseValue = function getPromiseValue2() { + return "Promise{\u2026}"; + }; + try { + var _process$binding = process.binding("util"), getPromiseDetails = _process$binding.getPromiseDetails, kPending = _process$binding.kPending, kRejected = _process$binding.kRejected; + if (Array.isArray(getPromiseDetails(Promise.resolve()))) { + getPromiseValue = function getPromiseValue2(value, options) { + var _getPromiseDetails = getPromiseDetails(value), _getPromiseDetails2 = _slicedToArray(_getPromiseDetails, 2), state = _getPromiseDetails2[0], innerValue = _getPromiseDetails2[1]; + if (state === kPending) { + return "Promise{}"; + } + return "Promise".concat(state === kRejected ? "!" : "", "{").concat(options.inspect(innerValue, options), "}"); + }; + } + } catch (notNode) { + } + var inspectPromise = getPromiseValue; + function inspectObject(object, options) { + var properties = Object.getOwnPropertyNames(object); + var symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : []; + if (properties.length === 0 && symbols.length === 0) { + return "{}"; + } + options.truncate -= 4; + options.seen = options.seen || []; + if (options.seen.indexOf(object) >= 0) { + return "[Circular]"; + } + options.seen.push(object); + var propertyContents = inspectList(properties.map(function(key) { + return [key, object[key]]; + }), options, inspectProperty); + var symbolContents = inspectList(symbols.map(function(key) { + return [key, object[key]]; + }), options, inspectProperty); + options.seen.pop(); + var sep = ""; + if (propertyContents && symbolContents) { + sep = ", "; + } + return "{ ".concat(propertyContents).concat(sep).concat(symbolContents, " }"); + } + var toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag ? Symbol.toStringTag : false; + function inspectClass(value, options) { + var name = ""; + if (toStringTag && toStringTag in value) { + name = value[toStringTag]; + } + name = name || getFuncName_1(value.constructor); + if (!name || name === "_class") { + name = ""; + } + options.truncate -= name.length; + return "".concat(name).concat(inspectObject(value, options)); + } + function inspectArguments(args, options) { + if (args.length === 0) + return "Arguments[]"; + options.truncate -= 13; + return "Arguments[ ".concat(inspectList(args, options), " ]"); + } + var errorKeys = ["stack", "line", "column", "name", "message", "fileName", "lineNumber", "columnNumber", "number", "description"]; + function inspectObject$1(error, options) { + var properties = Object.getOwnPropertyNames(error).filter(function(key) { + return errorKeys.indexOf(key) === -1; + }); + var name = error.name; + options.truncate -= name.length; + var message = ""; + if (typeof error.message === "string") { + message = truncate(error.message, options.truncate); + } else { + properties.unshift("message"); + } + message = message ? ": ".concat(message) : ""; + options.truncate -= message.length + 5; + var propertyContents = inspectList(properties.map(function(key) { + return [key, error[key]]; + }), options, inspectProperty); + return "".concat(name).concat(message).concat(propertyContents ? " { ".concat(propertyContents, " }") : ""); + } + function inspectAttribute(_ref, options) { + var _ref2 = _slicedToArray(_ref, 2), key = _ref2[0], value = _ref2[1]; + options.truncate -= 3; + if (!value) { + return "".concat(options.stylize(key, "yellow")); + } + return "".concat(options.stylize(key, "yellow"), "=").concat(options.stylize('"'.concat(value, '"'), "string")); + } + function inspectHTMLCollection(collection, options) { + return inspectList(collection, options, inspectHTML, "\n"); + } + function inspectHTML(element, options) { + var properties = element.getAttributeNames(); + var name = element.tagName.toLowerCase(); + var head = options.stylize("<".concat(name), "special"); + var headClose = options.stylize(">", "special"); + var tail = options.stylize(""), "special"); + options.truncate -= name.length * 2 + 5; + var propertyContents = ""; + if (properties.length > 0) { + propertyContents += " "; + propertyContents += inspectList(properties.map(function(key) { + return [key, element.getAttribute(key)]; + }), options, inspectAttribute, " "); + } + options.truncate -= propertyContents.length; + var truncate2 = options.truncate; + var children = inspectHTMLCollection(element.children, options); + if (children && children.length > truncate2) { + children = "".concat(truncator, "(").concat(element.children.length, ")"); + } + return "".concat(head).concat(propertyContents).concat(headClose).concat(children).concat(tail); + } + var symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function"; + var chaiInspect = symbolsSupported ? Symbol.for("chai/inspect") : "@@chai/inspect"; + var nodeInspect = false; + try { + var nodeUtil = __require("util"); + nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false; + } catch (noNodeInspect) { + nodeInspect = false; + } + function FakeMap() { + this.key = "chai/loupe__" + Math.random() + Date.now(); + } + FakeMap.prototype = { + // eslint-disable-next-line object-shorthand + get: function get(key) { + return key[this.key]; + }, + // eslint-disable-next-line object-shorthand + has: function has(key) { + return this.key in key; + }, + // eslint-disable-next-line object-shorthand + set: function set(key, value) { + if (Object.isExtensible(key)) { + Object.defineProperty(key, this.key, { + // eslint-disable-next-line object-shorthand + value, + configurable: true + }); + } + } + }; + var constructorMap = new (typeof WeakMap === "function" ? WeakMap : FakeMap)(); + var stringTagMap = {}; + var baseTypesMap = { + undefined: function undefined$1(value, options) { + return options.stylize("undefined", "undefined"); + }, + null: function _null(value, options) { + return options.stylize(null, "null"); + }, + boolean: function boolean(value, options) { + return options.stylize(value, "boolean"); + }, + Boolean: function Boolean2(value, options) { + return options.stylize(value, "boolean"); + }, + number: inspectNumber, + Number: inspectNumber, + bigint: inspectBigInt, + BigInt: inspectBigInt, + string: inspectString, + String: inspectString, + function: inspectFunction, + Function: inspectFunction, + symbol: inspectSymbol, + // A Symbol polyfill will return `Symbol` not `symbol` from typedetect + Symbol: inspectSymbol, + Array: inspectArray, + Date: inspectDate, + Map: inspectMap, + Set: inspectSet, + RegExp: inspectRegExp, + Promise: inspectPromise, + // WeakSet, WeakMap are totally opaque to us + WeakSet: function WeakSet2(value, options) { + return options.stylize("WeakSet{\u2026}", "special"); + }, + WeakMap: function WeakMap2(value, options) { + return options.stylize("WeakMap{\u2026}", "special"); + }, + Arguments: inspectArguments, + Int8Array: inspectTypedArray, + Uint8Array: inspectTypedArray, + Uint8ClampedArray: inspectTypedArray, + Int16Array: inspectTypedArray, + Uint16Array: inspectTypedArray, + Int32Array: inspectTypedArray, + Uint32Array: inspectTypedArray, + Float32Array: inspectTypedArray, + Float64Array: inspectTypedArray, + Generator: function Generator() { + return ""; + }, + DataView: function DataView2() { + return ""; + }, + ArrayBuffer: function ArrayBuffer2() { + return ""; + }, + Error: inspectObject$1, + HTMLCollection: inspectHTMLCollection, + NodeList: inspectHTMLCollection + }; + var inspectCustom = function inspectCustom2(value, options, type) { + if (chaiInspect in value && typeof value[chaiInspect] === "function") { + return value[chaiInspect](options); + } + if (nodeInspect && nodeInspect in value && typeof value[nodeInspect] === "function") { + return value[nodeInspect](options.depth, options); + } + if ("inspect" in value && typeof value.inspect === "function") { + return value.inspect(options.depth, options); + } + if ("constructor" in value && constructorMap.has(value.constructor)) { + return constructorMap.get(value.constructor)(value, options); + } + if (stringTagMap[type]) { + return stringTagMap[type](value, options); + } + return ""; + }; + var toString$1 = Object.prototype.toString; + function inspect2(value, options) { + options = normaliseOptions(options); + options.inspect = inspect2; + var _options = options, customInspect = _options.customInspect; + var type = value === null ? "null" : _typeof(value); + if (type === "object") { + type = toString$1.call(value).slice(8, -1); + } + if (baseTypesMap[type]) { + return baseTypesMap[type](value, options); + } + if (customInspect && value) { + var output = inspectCustom(value, options, type); + if (output) { + if (typeof output === "string") + return output; + return inspect2(output, options); + } + } + var proto = value ? Object.getPrototypeOf(value) : false; + if (proto === Object.prototype || proto === null) { + return inspectObject(value, options); + } + if (value && typeof HTMLElement === "function" && value instanceof HTMLElement) { + return inspectHTML(value, options); + } + if ("constructor" in value) { + if (value.constructor !== Object) { + return inspectClass(value, options); + } + return inspectObject(value, options); + } + if (value === Object(value)) { + return inspectObject(value, options); + } + return options.stylize(String(value), type); + } + function registerConstructor(constructor, inspector) { + if (constructorMap.has(constructor)) { + return false; + } + constructorMap.set(constructor, inspector); + return true; + } + function registerStringTag(stringTag, inspector) { + if (stringTag in stringTagMap) { + return false; + } + stringTagMap[stringTag] = inspector; + return true; + } + var custom = chaiInspect; + exports2.custom = custom; + exports2.default = inspect2; + exports2.inspect = inspect2; + exports2.registerConstructor = registerConstructor; + exports2.registerStringTag = registerStringTag; + Object.defineProperty(exports2, "__esModule", { value: true }); + }); + } +}); + +// node_modules/chai/lib/chai/config.js +var require_config = __commonJS({ + "node_modules/chai/lib/chai/config.js"(exports, module) { + init_cjs_shim(); + module.exports = { + /** + * ### config.includeStack + * + * User configurable property, influences whether stack trace + * is included in Assertion error message. Default of false + * suppresses stack trace in the error message. + * + * chai.config.includeStack = true; // enable stack on error + * + * @param {Boolean} + * @api public + */ + includeStack: false, + /** + * ### config.showDiff + * + * User configurable property, influences whether or not + * the `showDiff` flag should be included in the thrown + * AssertionErrors. `false` will always be `false`; `true` + * will be true when the assertion has requested a diff + * be shown. + * + * @param {Boolean} + * @api public + */ + showDiff: true, + /** + * ### config.truncateThreshold + * + * User configurable property, sets length threshold for actual and + * expected values in assertion errors. If this threshold is exceeded, for + * example for large data structures, the value is replaced with something + * like `[ Array(3) ]` or `{ Object (prop1, prop2) }`. + * + * Set it to zero if you want to disable truncating altogether. + * + * This is especially userful when doing assertions on arrays: having this + * set to a reasonable large value makes the failure messages readily + * inspectable. + * + * chai.config.truncateThreshold = 0; // disable truncating + * + * @param {Number} + * @api public + */ + truncateThreshold: 40, + /** + * ### config.useProxy + * + * User configurable property, defines if chai will use a Proxy to throw + * an error when a non-existent property is read, which protects users + * from typos when using property-based assertions. + * + * Set it to false if you want to disable this feature. + * + * chai.config.useProxy = false; // disable use of Proxy + * + * This feature is automatically disabled regardless of this config value + * in environments that don't support proxies. + * + * @param {Boolean} + * @api public + */ + useProxy: true, + /** + * ### config.proxyExcludedKeys + * + * User configurable property, defines which properties should be ignored + * instead of throwing an error if they do not exist on the assertion. + * This is only applied if the environment Chai is running in supports proxies and + * if the `useProxy` configuration setting is enabled. + * By default, `then` and `inspect` will not throw an error if they do not exist on the + * assertion object because the `.inspect` property is read by `util.inspect` (for example, when + * using `console.log` on the assertion object) and `.then` is necessary for promise type-checking. + * + * // By default these keys will not throw an error if they do not exist on the assertion object + * chai.config.proxyExcludedKeys = ['then', 'inspect']; + * + * @param {Array} + * @api public + */ + proxyExcludedKeys: ["then", "catch", "inspect", "toJSON"], + /** + * ### config.deepEqual + * + * User configurable property, defines which a custom function to use for deepEqual + * comparisons. + * By default, the function used is the one from the `deep-eql` package without custom comparator. + * + * // use a custom comparator + * chai.config.deepEqual = (expected, actual) => { + * return chai.util.eql(expected, actual, { + * comparator: (expected, actual) => { + * // for non number comparison, use the default behavior + * if(typeof expected !== 'number') return null; + * // allow a difference of 10 between compared numbers + * return typeof actual === 'number' && Math.abs(actual - expected) < 10 + * } + * }) + * }; + * + * @param {Function} + * @api public + */ + deepEqual: null + }; + } +}); + +// node_modules/chai/lib/chai/utils/inspect.js +var require_inspect = __commonJS({ + "node_modules/chai/lib/chai/utils/inspect.js"(exports, module) { + init_cjs_shim(); + var getName = require_get_func_name(); + var loupe = require_loupe(); + var config2 = require_config(); + module.exports = inspect2; + function inspect2(obj, showHidden, depth, colors) { + var options = { + colors, + depth: typeof depth === "undefined" ? 2 : depth, + showHidden, + truncate: config2.truncateThreshold ? config2.truncateThreshold : Infinity + }; + return loupe.inspect(obj, options); + } + } +}); + +// node_modules/chai/lib/chai/utils/objDisplay.js +var require_objDisplay = __commonJS({ + "node_modules/chai/lib/chai/utils/objDisplay.js"(exports, module) { + init_cjs_shim(); + var inspect2 = require_inspect(); + var config2 = require_config(); + module.exports = function objDisplay(obj) { + var str = inspect2(obj), type = Object.prototype.toString.call(obj); + if (config2.truncateThreshold && str.length >= config2.truncateThreshold) { + if (type === "[object Function]") { + return !obj.name || obj.name === "" ? "[Function]" : "[Function: " + obj.name + "]"; + } else if (type === "[object Array]") { + return "[ Array(" + obj.length + ") ]"; + } else if (type === "[object Object]") { + var keys = Object.keys(obj), kstr = keys.length > 2 ? keys.splice(0, 2).join(", ") + ", ..." : keys.join(", "); + return "{ Object (" + kstr + ") }"; + } else { + return str; + } + } else { + return str; + } + }; + } +}); + +// node_modules/chai/lib/chai/utils/getMessage.js +var require_getMessage = __commonJS({ + "node_modules/chai/lib/chai/utils/getMessage.js"(exports, module) { + init_cjs_shim(); + var flag = require_flag(); + var getActual = require_getActual(); + var objDisplay = require_objDisplay(); + module.exports = function getMessage(obj, args) { + var negate = flag(obj, "negate"), val = flag(obj, "object"), expected = args[3], actual = getActual(obj, args), msg = negate ? args[2] : args[1], flagMsg = flag(obj, "message"); + if (typeof msg === "function") + msg = msg(); + msg = msg || ""; + msg = msg.replace(/#\{this\}/g, function() { + return objDisplay(val); + }).replace(/#\{act\}/g, function() { + return objDisplay(actual); + }).replace(/#\{exp\}/g, function() { + return objDisplay(expected); + }); + return flagMsg ? flagMsg + ": " + msg : msg; + }; + } +}); + +// node_modules/chai/lib/chai/utils/transferFlags.js +var require_transferFlags = __commonJS({ + "node_modules/chai/lib/chai/utils/transferFlags.js"(exports, module) { + init_cjs_shim(); + module.exports = function transferFlags(assertion, object, includeAll) { + var flags = assertion.__flags || (assertion.__flags = /* @__PURE__ */ Object.create(null)); + if (!object.__flags) { + object.__flags = /* @__PURE__ */ Object.create(null); + } + includeAll = arguments.length === 3 ? includeAll : true; + for (var flag in flags) { + if (includeAll || flag !== "object" && flag !== "ssfi" && flag !== "lockSsfi" && flag != "message") { + object.__flags[flag] = flags[flag]; + } + } + }; + } +}); + +// node_modules/deep-eql/index.js +var require_deep_eql = __commonJS({ + "node_modules/deep-eql/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var type = require_type_detect(); + function FakeMap() { + this._key = "chai/deep-eql__" + Math.random() + Date.now(); + } + FakeMap.prototype = { + get: function get(key) { + return key[this._key]; + }, + set: function set(key, value) { + if (Object.isExtensible(key)) { + Object.defineProperty(key, this._key, { + value, + configurable: true + }); + } + } + }; + var MemoizeMap = typeof WeakMap === "function" ? WeakMap : FakeMap; + function memoizeCompare(leftHandOperand, rightHandOperand, memoizeMap) { + if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) { + return null; + } + var leftHandMap = memoizeMap.get(leftHandOperand); + if (leftHandMap) { + var result = leftHandMap.get(rightHandOperand); + if (typeof result === "boolean") { + return result; + } + } + return null; + } + function memoizeSet(leftHandOperand, rightHandOperand, memoizeMap, result) { + if (!memoizeMap || isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) { + return; + } + var leftHandMap = memoizeMap.get(leftHandOperand); + if (leftHandMap) { + leftHandMap.set(rightHandOperand, result); + } else { + leftHandMap = new MemoizeMap(); + leftHandMap.set(rightHandOperand, result); + memoizeMap.set(leftHandOperand, leftHandMap); + } + } + module.exports = deepEqual; + module.exports.MemoizeMap = MemoizeMap; + function deepEqual(leftHandOperand, rightHandOperand, options) { + if (options && options.comparator) { + return extensiveDeepEqual(leftHandOperand, rightHandOperand, options); + } + var simpleResult = simpleEqual(leftHandOperand, rightHandOperand); + if (simpleResult !== null) { + return simpleResult; + } + return extensiveDeepEqual(leftHandOperand, rightHandOperand, options); + } + function simpleEqual(leftHandOperand, rightHandOperand) { + if (leftHandOperand === rightHandOperand) { + return leftHandOperand !== 0 || 1 / leftHandOperand === 1 / rightHandOperand; + } + if (leftHandOperand !== leftHandOperand && // eslint-disable-line no-self-compare + rightHandOperand !== rightHandOperand) { + return true; + } + if (isPrimitive(leftHandOperand) || isPrimitive(rightHandOperand)) { + return false; + } + return null; + } + function extensiveDeepEqual(leftHandOperand, rightHandOperand, options) { + options = options || {}; + options.memoize = options.memoize === false ? false : options.memoize || new MemoizeMap(); + var comparator = options && options.comparator; + var memoizeResultLeft = memoizeCompare(leftHandOperand, rightHandOperand, options.memoize); + if (memoizeResultLeft !== null) { + return memoizeResultLeft; + } + var memoizeResultRight = memoizeCompare(rightHandOperand, leftHandOperand, options.memoize); + if (memoizeResultRight !== null) { + return memoizeResultRight; + } + if (comparator) { + var comparatorResult = comparator(leftHandOperand, rightHandOperand); + if (comparatorResult === false || comparatorResult === true) { + memoizeSet(leftHandOperand, rightHandOperand, options.memoize, comparatorResult); + return comparatorResult; + } + var simpleResult = simpleEqual(leftHandOperand, rightHandOperand); + if (simpleResult !== null) { + return simpleResult; + } + } + var leftHandType = type(leftHandOperand); + if (leftHandType !== type(rightHandOperand)) { + memoizeSet(leftHandOperand, rightHandOperand, options.memoize, false); + return false; + } + memoizeSet(leftHandOperand, rightHandOperand, options.memoize, true); + var result = extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options); + memoizeSet(leftHandOperand, rightHandOperand, options.memoize, result); + return result; + } + function extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options) { + switch (leftHandType) { + case "String": + case "Number": + case "Boolean": + case "Date": + return deepEqual(leftHandOperand.valueOf(), rightHandOperand.valueOf()); + case "Promise": + case "Symbol": + case "function": + case "WeakMap": + case "WeakSet": + return leftHandOperand === rightHandOperand; + case "Error": + return keysEqual(leftHandOperand, rightHandOperand, ["name", "message", "code"], options); + case "Arguments": + case "Int8Array": + case "Uint8Array": + case "Uint8ClampedArray": + case "Int16Array": + case "Uint16Array": + case "Int32Array": + case "Uint32Array": + case "Float32Array": + case "Float64Array": + case "Array": + return iterableEqual(leftHandOperand, rightHandOperand, options); + case "RegExp": + return regexpEqual(leftHandOperand, rightHandOperand); + case "Generator": + return generatorEqual(leftHandOperand, rightHandOperand, options); + case "DataView": + return iterableEqual(new Uint8Array(leftHandOperand.buffer), new Uint8Array(rightHandOperand.buffer), options); + case "ArrayBuffer": + return iterableEqual(new Uint8Array(leftHandOperand), new Uint8Array(rightHandOperand), options); + case "Set": + return entriesEqual(leftHandOperand, rightHandOperand, options); + case "Map": + return entriesEqual(leftHandOperand, rightHandOperand, options); + case "Temporal.PlainDate": + case "Temporal.PlainTime": + case "Temporal.PlainDateTime": + case "Temporal.Instant": + case "Temporal.ZonedDateTime": + case "Temporal.PlainYearMonth": + case "Temporal.PlainMonthDay": + return leftHandOperand.equals(rightHandOperand); + case "Temporal.Duration": + return leftHandOperand.total("nanoseconds") === rightHandOperand.total("nanoseconds"); + case "Temporal.TimeZone": + case "Temporal.Calendar": + return leftHandOperand.toString() === rightHandOperand.toString(); + default: + return objectEqual(leftHandOperand, rightHandOperand, options); + } + } + function regexpEqual(leftHandOperand, rightHandOperand) { + return leftHandOperand.toString() === rightHandOperand.toString(); + } + function entriesEqual(leftHandOperand, rightHandOperand, options) { + try { + if (leftHandOperand.size !== rightHandOperand.size) { + return false; + } + if (leftHandOperand.size === 0) { + return true; + } + } catch (sizeError) { + return false; + } + var leftHandItems = []; + var rightHandItems = []; + leftHandOperand.forEach(function gatherEntries(key, value) { + leftHandItems.push([key, value]); + }); + rightHandOperand.forEach(function gatherEntries(key, value) { + rightHandItems.push([key, value]); + }); + return iterableEqual(leftHandItems.sort(), rightHandItems.sort(), options); + } + function iterableEqual(leftHandOperand, rightHandOperand, options) { + var length = leftHandOperand.length; + if (length !== rightHandOperand.length) { + return false; + } + if (length === 0) { + return true; + } + var index = -1; + while (++index < length) { + if (deepEqual(leftHandOperand[index], rightHandOperand[index], options) === false) { + return false; + } + } + return true; + } + function generatorEqual(leftHandOperand, rightHandOperand, options) { + return iterableEqual(getGeneratorEntries(leftHandOperand), getGeneratorEntries(rightHandOperand), options); + } + function hasIteratorFunction(target) { + return typeof Symbol !== "undefined" && typeof target === "object" && typeof Symbol.iterator !== "undefined" && typeof target[Symbol.iterator] === "function"; + } + function getIteratorEntries(target) { + if (hasIteratorFunction(target)) { + try { + return getGeneratorEntries(target[Symbol.iterator]()); + } catch (iteratorError) { + return []; + } + } + return []; + } + function getGeneratorEntries(generator) { + var generatorResult = generator.next(); + var accumulator = [generatorResult.value]; + while (generatorResult.done === false) { + generatorResult = generator.next(); + accumulator.push(generatorResult.value); + } + return accumulator; + } + function getEnumerableKeys(target) { + var keys = []; + for (var key in target) { + keys.push(key); + } + return keys; + } + function getEnumerableSymbols(target) { + var keys = []; + var allKeys = Object.getOwnPropertySymbols(target); + for (var i = 0; i < allKeys.length; i += 1) { + var key = allKeys[i]; + if (Object.getOwnPropertyDescriptor(target, key).enumerable) { + keys.push(key); + } + } + return keys; + } + function keysEqual(leftHandOperand, rightHandOperand, keys, options) { + var length = keys.length; + if (length === 0) { + return true; + } + for (var i = 0; i < length; i += 1) { + if (deepEqual(leftHandOperand[keys[i]], rightHandOperand[keys[i]], options) === false) { + return false; + } + } + return true; + } + function objectEqual(leftHandOperand, rightHandOperand, options) { + var leftHandKeys = getEnumerableKeys(leftHandOperand); + var rightHandKeys = getEnumerableKeys(rightHandOperand); + var leftHandSymbols = getEnumerableSymbols(leftHandOperand); + var rightHandSymbols = getEnumerableSymbols(rightHandOperand); + leftHandKeys = leftHandKeys.concat(leftHandSymbols); + rightHandKeys = rightHandKeys.concat(rightHandSymbols); + if (leftHandKeys.length && leftHandKeys.length === rightHandKeys.length) { + if (iterableEqual(mapSymbols(leftHandKeys).sort(), mapSymbols(rightHandKeys).sort()) === false) { + return false; + } + return keysEqual(leftHandOperand, rightHandOperand, leftHandKeys, options); + } + var leftHandEntries = getIteratorEntries(leftHandOperand); + var rightHandEntries = getIteratorEntries(rightHandOperand); + if (leftHandEntries.length && leftHandEntries.length === rightHandEntries.length) { + leftHandEntries.sort(); + rightHandEntries.sort(); + return iterableEqual(leftHandEntries, rightHandEntries, options); + } + if (leftHandKeys.length === 0 && leftHandEntries.length === 0 && rightHandKeys.length === 0 && rightHandEntries.length === 0) { + return true; + } + return false; + } + function isPrimitive(value) { + return value === null || typeof value !== "object"; + } + function mapSymbols(arr) { + return arr.map(function mapSymbol(entry) { + if (typeof entry === "symbol") { + return entry.toString(); + } + return entry; + }); + } + } +}); + +// node_modules/chai/lib/chai/utils/isProxyEnabled.js +var require_isProxyEnabled = __commonJS({ + "node_modules/chai/lib/chai/utils/isProxyEnabled.js"(exports, module) { + init_cjs_shim(); + var config2 = require_config(); + module.exports = function isProxyEnabled() { + return config2.useProxy && typeof Proxy !== "undefined" && typeof Reflect !== "undefined"; + }; + } +}); + +// node_modules/chai/lib/chai/utils/addProperty.js +var require_addProperty = __commonJS({ + "node_modules/chai/lib/chai/utils/addProperty.js"(exports, module) { + init_cjs_shim(); + var chai2 = require_chai(); + var flag = require_flag(); + var isProxyEnabled = require_isProxyEnabled(); + var transferFlags = require_transferFlags(); + module.exports = function addProperty(ctx, name, getter) { + getter = getter === void 0 ? function() { + } : getter; + Object.defineProperty( + ctx, + name, + { + get: function propertyGetter() { + if (!isProxyEnabled() && !flag(this, "lockSsfi")) { + flag(this, "ssfi", propertyGetter); + } + var result = getter.call(this); + if (result !== void 0) + return result; + var newAssertion = new chai2.Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }, + configurable: true + } + ); + }; + } +}); + +// node_modules/chai/lib/chai/utils/addLengthGuard.js +var require_addLengthGuard = __commonJS({ + "node_modules/chai/lib/chai/utils/addLengthGuard.js"(exports, module) { + init_cjs_shim(); + var fnLengthDesc = Object.getOwnPropertyDescriptor(function() { + }, "length"); + module.exports = function addLengthGuard(fn, assertionName, isChainable) { + if (!fnLengthDesc.configurable) + return fn; + Object.defineProperty(fn, "length", { + get: function() { + if (isChainable) { + throw Error("Invalid Chai property: " + assertionName + '.length. Due to a compatibility issue, "length" cannot directly follow "' + assertionName + '". Use "' + assertionName + '.lengthOf" instead.'); + } + throw Error("Invalid Chai property: " + assertionName + '.length. See docs for proper usage of "' + assertionName + '".'); + } + }); + return fn; + }; + } +}); + +// node_modules/chai/lib/chai/utils/getProperties.js +var require_getProperties = __commonJS({ + "node_modules/chai/lib/chai/utils/getProperties.js"(exports, module) { + init_cjs_shim(); + module.exports = function getProperties(object) { + var result = Object.getOwnPropertyNames(object); + function addProperty(property) { + if (result.indexOf(property) === -1) { + result.push(property); + } + } + var proto = Object.getPrototypeOf(object); + while (proto !== null) { + Object.getOwnPropertyNames(proto).forEach(addProperty); + proto = Object.getPrototypeOf(proto); + } + return result; + }; + } +}); + +// node_modules/chai/lib/chai/utils/proxify.js +var require_proxify = __commonJS({ + "node_modules/chai/lib/chai/utils/proxify.js"(exports, module) { + init_cjs_shim(); + var config2 = require_config(); + var flag = require_flag(); + var getProperties = require_getProperties(); + var isProxyEnabled = require_isProxyEnabled(); + var builtins = ["__flags", "__methods", "_obj", "assert"]; + module.exports = function proxify(obj, nonChainableMethodName) { + if (!isProxyEnabled()) + return obj; + return new Proxy(obj, { + get: function proxyGetter(target, property) { + if (typeof property === "string" && config2.proxyExcludedKeys.indexOf(property) === -1 && !Reflect.has(target, property)) { + if (nonChainableMethodName) { + throw Error("Invalid Chai property: " + nonChainableMethodName + "." + property + '. See docs for proper usage of "' + nonChainableMethodName + '".'); + } + var suggestion = null; + var suggestionDistance = 4; + getProperties(target).forEach(function(prop) { + if (!Object.prototype.hasOwnProperty(prop) && builtins.indexOf(prop) === -1) { + var dist = stringDistanceCapped( + property, + prop, + suggestionDistance + ); + if (dist < suggestionDistance) { + suggestion = prop; + suggestionDistance = dist; + } + } + }); + if (suggestion !== null) { + throw Error("Invalid Chai property: " + property + '. Did you mean "' + suggestion + '"?'); + } else { + throw Error("Invalid Chai property: " + property); + } + } + if (builtins.indexOf(property) === -1 && !flag(target, "lockSsfi")) { + flag(target, "ssfi", proxyGetter); + } + return Reflect.get(target, property); + } + }); + }; + function stringDistanceCapped(strA, strB, cap) { + if (Math.abs(strA.length - strB.length) >= cap) { + return cap; + } + var memo = []; + for (var i = 0; i <= strA.length; i++) { + memo[i] = Array(strB.length + 1).fill(0); + memo[i][0] = i; + } + for (var j = 0; j < strB.length; j++) { + memo[0][j] = j; + } + for (var i = 1; i <= strA.length; i++) { + var ch = strA.charCodeAt(i - 1); + for (var j = 1; j <= strB.length; j++) { + if (Math.abs(i - j) >= cap) { + memo[i][j] = cap; + continue; + } + memo[i][j] = Math.min( + memo[i - 1][j] + 1, + memo[i][j - 1] + 1, + memo[i - 1][j - 1] + (ch === strB.charCodeAt(j - 1) ? 0 : 1) + ); + } + } + return memo[strA.length][strB.length]; + } + } +}); + +// node_modules/chai/lib/chai/utils/addMethod.js +var require_addMethod = __commonJS({ + "node_modules/chai/lib/chai/utils/addMethod.js"(exports, module) { + init_cjs_shim(); + var addLengthGuard = require_addLengthGuard(); + var chai2 = require_chai(); + var flag = require_flag(); + var proxify = require_proxify(); + var transferFlags = require_transferFlags(); + module.exports = function addMethod(ctx, name, method) { + var methodWrapper = function() { + if (!flag(this, "lockSsfi")) { + flag(this, "ssfi", methodWrapper); + } + var result = method.apply(this, arguments); + if (result !== void 0) + return result; + var newAssertion = new chai2.Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }; + addLengthGuard(methodWrapper, name, false); + ctx[name] = proxify(methodWrapper, name); + }; + } +}); + +// node_modules/chai/lib/chai/utils/overwriteProperty.js +var require_overwriteProperty = __commonJS({ + "node_modules/chai/lib/chai/utils/overwriteProperty.js"(exports, module) { + init_cjs_shim(); + var chai2 = require_chai(); + var flag = require_flag(); + var isProxyEnabled = require_isProxyEnabled(); + var transferFlags = require_transferFlags(); + module.exports = function overwriteProperty(ctx, name, getter) { + var _get = Object.getOwnPropertyDescriptor(ctx, name), _super = function() { + }; + if (_get && "function" === typeof _get.get) + _super = _get.get; + Object.defineProperty( + ctx, + name, + { + get: function overwritingPropertyGetter() { + if (!isProxyEnabled() && !flag(this, "lockSsfi")) { + flag(this, "ssfi", overwritingPropertyGetter); + } + var origLockSsfi = flag(this, "lockSsfi"); + flag(this, "lockSsfi", true); + var result = getter(_super).call(this); + flag(this, "lockSsfi", origLockSsfi); + if (result !== void 0) { + return result; + } + var newAssertion = new chai2.Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }, + configurable: true + } + ); + }; + } +}); + +// node_modules/chai/lib/chai/utils/overwriteMethod.js +var require_overwriteMethod = __commonJS({ + "node_modules/chai/lib/chai/utils/overwriteMethod.js"(exports, module) { + init_cjs_shim(); + var addLengthGuard = require_addLengthGuard(); + var chai2 = require_chai(); + var flag = require_flag(); + var proxify = require_proxify(); + var transferFlags = require_transferFlags(); + module.exports = function overwriteMethod(ctx, name, method) { + var _method = ctx[name], _super = function() { + throw new Error(name + " is not a function"); + }; + if (_method && "function" === typeof _method) + _super = _method; + var overwritingMethodWrapper = function() { + if (!flag(this, "lockSsfi")) { + flag(this, "ssfi", overwritingMethodWrapper); + } + var origLockSsfi = flag(this, "lockSsfi"); + flag(this, "lockSsfi", true); + var result = method(_super).apply(this, arguments); + flag(this, "lockSsfi", origLockSsfi); + if (result !== void 0) { + return result; + } + var newAssertion = new chai2.Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }; + addLengthGuard(overwritingMethodWrapper, name, false); + ctx[name] = proxify(overwritingMethodWrapper, name); + }; + } +}); + +// node_modules/chai/lib/chai/utils/addChainableMethod.js +var require_addChainableMethod = __commonJS({ + "node_modules/chai/lib/chai/utils/addChainableMethod.js"(exports, module) { + init_cjs_shim(); + var addLengthGuard = require_addLengthGuard(); + var chai2 = require_chai(); + var flag = require_flag(); + var proxify = require_proxify(); + var transferFlags = require_transferFlags(); + var canSetPrototype = typeof Object.setPrototypeOf === "function"; + var testFn = function() { + }; + var excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) { + var propDesc = Object.getOwnPropertyDescriptor(testFn, name); + if (typeof propDesc !== "object") + return true; + return !propDesc.configurable; + }); + var call = Function.prototype.call; + var apply = Function.prototype.apply; + module.exports = function addChainableMethod(ctx, name, method, chainingBehavior) { + if (typeof chainingBehavior !== "function") { + chainingBehavior = function() { + }; + } + var chainableBehavior = { + method, + chainingBehavior + }; + if (!ctx.__methods) { + ctx.__methods = {}; + } + ctx.__methods[name] = chainableBehavior; + Object.defineProperty( + ctx, + name, + { + get: function chainableMethodGetter() { + chainableBehavior.chainingBehavior.call(this); + var chainableMethodWrapper = function() { + if (!flag(this, "lockSsfi")) { + flag(this, "ssfi", chainableMethodWrapper); + } + var result = chainableBehavior.method.apply(this, arguments); + if (result !== void 0) { + return result; + } + var newAssertion = new chai2.Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }; + addLengthGuard(chainableMethodWrapper, name, true); + if (canSetPrototype) { + var prototype = Object.create(this); + prototype.call = call; + prototype.apply = apply; + Object.setPrototypeOf(chainableMethodWrapper, prototype); + } else { + var asserterNames = Object.getOwnPropertyNames(ctx); + asserterNames.forEach(function(asserterName) { + if (excludeNames.indexOf(asserterName) !== -1) { + return; + } + var pd = Object.getOwnPropertyDescriptor(ctx, asserterName); + Object.defineProperty(chainableMethodWrapper, asserterName, pd); + }); + } + transferFlags(this, chainableMethodWrapper); + return proxify(chainableMethodWrapper); + }, + configurable: true + } + ); + }; + } +}); + +// node_modules/chai/lib/chai/utils/overwriteChainableMethod.js +var require_overwriteChainableMethod = __commonJS({ + "node_modules/chai/lib/chai/utils/overwriteChainableMethod.js"(exports, module) { + init_cjs_shim(); + var chai2 = require_chai(); + var transferFlags = require_transferFlags(); + module.exports = function overwriteChainableMethod(ctx, name, method, chainingBehavior) { + var chainableBehavior = ctx.__methods[name]; + var _chainingBehavior = chainableBehavior.chainingBehavior; + chainableBehavior.chainingBehavior = function overwritingChainableMethodGetter() { + var result = chainingBehavior(_chainingBehavior).call(this); + if (result !== void 0) { + return result; + } + var newAssertion = new chai2.Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }; + var _method = chainableBehavior.method; + chainableBehavior.method = function overwritingChainableMethodWrapper() { + var result = method(_method).apply(this, arguments); + if (result !== void 0) { + return result; + } + var newAssertion = new chai2.Assertion(); + transferFlags(this, newAssertion); + return newAssertion; + }; + }; + } +}); + +// node_modules/chai/lib/chai/utils/compareByInspect.js +var require_compareByInspect = __commonJS({ + "node_modules/chai/lib/chai/utils/compareByInspect.js"(exports, module) { + init_cjs_shim(); + var inspect2 = require_inspect(); + module.exports = function compareByInspect(a, b) { + return inspect2(a) < inspect2(b) ? -1 : 1; + }; + } +}); + +// node_modules/chai/lib/chai/utils/getOwnEnumerablePropertySymbols.js +var require_getOwnEnumerablePropertySymbols = __commonJS({ + "node_modules/chai/lib/chai/utils/getOwnEnumerablePropertySymbols.js"(exports, module) { + init_cjs_shim(); + module.exports = function getOwnEnumerablePropertySymbols(obj) { + if (typeof Object.getOwnPropertySymbols !== "function") + return []; + return Object.getOwnPropertySymbols(obj).filter(function(sym) { + return Object.getOwnPropertyDescriptor(obj, sym).enumerable; + }); + }; + } +}); + +// node_modules/chai/lib/chai/utils/getOwnEnumerableProperties.js +var require_getOwnEnumerableProperties = __commonJS({ + "node_modules/chai/lib/chai/utils/getOwnEnumerableProperties.js"(exports, module) { + init_cjs_shim(); + var getOwnEnumerablePropertySymbols = require_getOwnEnumerablePropertySymbols(); + module.exports = function getOwnEnumerableProperties(obj) { + return Object.keys(obj).concat(getOwnEnumerablePropertySymbols(obj)); + }; + } +}); + +// node_modules/check-error/index.js +var require_check_error = __commonJS({ + "node_modules/check-error/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var getFunctionName = require_get_func_name(); + function compatibleInstance(thrown, errorLike) { + return errorLike instanceof Error && thrown === errorLike; + } + function compatibleConstructor(thrown, errorLike) { + if (errorLike instanceof Error) { + return thrown.constructor === errorLike.constructor || thrown instanceof errorLike.constructor; + } else if (errorLike.prototype instanceof Error || errorLike === Error) { + return thrown.constructor === errorLike || thrown instanceof errorLike; + } + return false; + } + function compatibleMessage(thrown, errMatcher) { + var comparisonString = typeof thrown === "string" ? thrown : thrown.message; + if (errMatcher instanceof RegExp) { + return errMatcher.test(comparisonString); + } else if (typeof errMatcher === "string") { + return comparisonString.indexOf(errMatcher) !== -1; + } + return false; + } + function getConstructorName(errorLike) { + var constructorName = errorLike; + if (errorLike instanceof Error) { + constructorName = getFunctionName(errorLike.constructor); + } else if (typeof errorLike === "function") { + constructorName = getFunctionName(errorLike); + if (constructorName === "") { + var newConstructorName = getFunctionName(new errorLike()); + constructorName = newConstructorName || constructorName; + } + } + return constructorName; + } + function getMessage(errorLike) { + var msg = ""; + if (errorLike && errorLike.message) { + msg = errorLike.message; + } else if (typeof errorLike === "string") { + msg = errorLike; + } + return msg; + } + module.exports = { + compatibleInstance, + compatibleConstructor, + compatibleMessage, + getMessage, + getConstructorName + }; + } +}); + +// node_modules/chai/lib/chai/utils/isNaN.js +var require_isNaN = __commonJS({ + "node_modules/chai/lib/chai/utils/isNaN.js"(exports, module) { + init_cjs_shim(); + function isNaN2(value) { + return value !== value; + } + module.exports = Number.isNaN || isNaN2; + } +}); + +// node_modules/chai/lib/chai/utils/getOperator.js +var require_getOperator = __commonJS({ + "node_modules/chai/lib/chai/utils/getOperator.js"(exports, module) { + init_cjs_shim(); + var type = require_type_detect(); + var flag = require_flag(); + function isObjectType(obj) { + var objectType = type(obj); + var objectTypes = ["Array", "Object", "function"]; + return objectTypes.indexOf(objectType) !== -1; + } + module.exports = function getOperator(obj, args) { + var operator = flag(obj, "operator"); + var negate = flag(obj, "negate"); + var expected = args[3]; + var msg = negate ? args[2] : args[1]; + if (operator) { + return operator; + } + if (typeof msg === "function") + msg = msg(); + msg = msg || ""; + if (!msg) { + return void 0; + } + if (/\shave\s/.test(msg)) { + return void 0; + } + var isObject = isObjectType(expected); + if (/\snot\s/.test(msg)) { + return isObject ? "notDeepStrictEqual" : "notStrictEqual"; + } + return isObject ? "deepStrictEqual" : "strictEqual"; + }; + } +}); + +// node_modules/chai/lib/chai/utils/index.js +var require_utils = __commonJS({ + "node_modules/chai/lib/chai/utils/index.js"(exports) { + init_cjs_shim(); + var pathval = require_pathval(); + exports.test = require_test(); + exports.type = require_type_detect(); + exports.expectTypes = require_expectTypes(); + exports.getMessage = require_getMessage(); + exports.getActual = require_getActual(); + exports.inspect = require_inspect(); + exports.objDisplay = require_objDisplay(); + exports.flag = require_flag(); + exports.transferFlags = require_transferFlags(); + exports.eql = require_deep_eql(); + exports.getPathInfo = pathval.getPathInfo; + exports.hasProperty = pathval.hasProperty; + exports.getName = require_get_func_name(); + exports.addProperty = require_addProperty(); + exports.addMethod = require_addMethod(); + exports.overwriteProperty = require_overwriteProperty(); + exports.overwriteMethod = require_overwriteMethod(); + exports.addChainableMethod = require_addChainableMethod(); + exports.overwriteChainableMethod = require_overwriteChainableMethod(); + exports.compareByInspect = require_compareByInspect(); + exports.getOwnEnumerablePropertySymbols = require_getOwnEnumerablePropertySymbols(); + exports.getOwnEnumerableProperties = require_getOwnEnumerableProperties(); + exports.checkError = require_check_error(); + exports.proxify = require_proxify(); + exports.addLengthGuard = require_addLengthGuard(); + exports.isProxyEnabled = require_isProxyEnabled(); + exports.isNaN = require_isNaN(); + exports.getOperator = require_getOperator(); + } +}); + +// node_modules/chai/lib/chai/assertion.js +var require_assertion = __commonJS({ + "node_modules/chai/lib/chai/assertion.js"(exports, module) { + init_cjs_shim(); + var config2 = require_config(); + module.exports = function(_chai, util2) { + var AssertionError2 = _chai.AssertionError, flag = util2.flag; + _chai.Assertion = Assertion2; + function Assertion2(obj, msg, ssfi, lockSsfi) { + flag(this, "ssfi", ssfi || Assertion2); + flag(this, "lockSsfi", lockSsfi); + flag(this, "object", obj); + flag(this, "message", msg); + flag(this, "eql", config2.deepEqual || util2.eql); + return util2.proxify(this); + } + Object.defineProperty(Assertion2, "includeStack", { + get: function() { + console.warn("Assertion.includeStack is deprecated, use chai.config.includeStack instead."); + return config2.includeStack; + }, + set: function(value) { + console.warn("Assertion.includeStack is deprecated, use chai.config.includeStack instead."); + config2.includeStack = value; + } + }); + Object.defineProperty(Assertion2, "showDiff", { + get: function() { + console.warn("Assertion.showDiff is deprecated, use chai.config.showDiff instead."); + return config2.showDiff; + }, + set: function(value) { + console.warn("Assertion.showDiff is deprecated, use chai.config.showDiff instead."); + config2.showDiff = value; + } + }); + Assertion2.addProperty = function(name, fn) { + util2.addProperty(this.prototype, name, fn); + }; + Assertion2.addMethod = function(name, fn) { + util2.addMethod(this.prototype, name, fn); + }; + Assertion2.addChainableMethod = function(name, fn, chainingBehavior) { + util2.addChainableMethod(this.prototype, name, fn, chainingBehavior); + }; + Assertion2.overwriteProperty = function(name, fn) { + util2.overwriteProperty(this.prototype, name, fn); + }; + Assertion2.overwriteMethod = function(name, fn) { + util2.overwriteMethod(this.prototype, name, fn); + }; + Assertion2.overwriteChainableMethod = function(name, fn, chainingBehavior) { + util2.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior); + }; + Assertion2.prototype.assert = function(expr, msg, negateMsg, expected, _actual, showDiff) { + var ok = util2.test(this, arguments); + if (false !== showDiff) + showDiff = true; + if (void 0 === expected && void 0 === _actual) + showDiff = false; + if (true !== config2.showDiff) + showDiff = false; + if (!ok) { + msg = util2.getMessage(this, arguments); + var actual = util2.getActual(this, arguments); + var assertionErrorObjectProperties = { + actual, + expected, + showDiff + }; + var operator = util2.getOperator(this, arguments); + if (operator) { + assertionErrorObjectProperties.operator = operator; + } + throw new AssertionError2( + msg, + assertionErrorObjectProperties, + config2.includeStack ? this.assert : flag(this, "ssfi") + ); + } + }; + Object.defineProperty( + Assertion2.prototype, + "_obj", + { + get: function() { + return flag(this, "object"); + }, + set: function(val) { + flag(this, "object", val); + } + } + ); + }; + } +}); + +// node_modules/chai/lib/chai/core/assertions.js +var require_assertions = __commonJS({ + "node_modules/chai/lib/chai/core/assertions.js"(exports, module) { + init_cjs_shim(); + module.exports = function(chai2, _) { + var Assertion2 = chai2.Assertion, AssertionError2 = chai2.AssertionError, flag = _.flag; + [ + "to", + "be", + "been", + "is", + "and", + "has", + "have", + "with", + "that", + "which", + "at", + "of", + "same", + "but", + "does", + "still", + "also" + ].forEach(function(chain) { + Assertion2.addProperty(chain); + }); + Assertion2.addProperty("not", function() { + flag(this, "negate", true); + }); + Assertion2.addProperty("deep", function() { + flag(this, "deep", true); + }); + Assertion2.addProperty("nested", function() { + flag(this, "nested", true); + }); + Assertion2.addProperty("own", function() { + flag(this, "own", true); + }); + Assertion2.addProperty("ordered", function() { + flag(this, "ordered", true); + }); + Assertion2.addProperty("any", function() { + flag(this, "any", true); + flag(this, "all", false); + }); + Assertion2.addProperty("all", function() { + flag(this, "all", true); + flag(this, "any", false); + }); + function an(type, msg) { + if (msg) + flag(this, "message", msg); + type = type.toLowerCase(); + var obj = flag(this, "object"), article = ~["a", "e", "i", "o", "u"].indexOf(type.charAt(0)) ? "an " : "a "; + this.assert( + type === _.type(obj).toLowerCase(), + "expected #{this} to be " + article + type, + "expected #{this} not to be " + article + type + ); + } + Assertion2.addChainableMethod("an", an); + Assertion2.addChainableMethod("a", an); + function SameValueZero(a, b) { + return _.isNaN(a) && _.isNaN(b) || a === b; + } + function includeChainingBehavior() { + flag(this, "contains", true); + } + function include(val, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), objType = _.type(obj).toLowerCase(), flagMsg = flag(this, "message"), negate = flag(this, "negate"), ssfi = flag(this, "ssfi"), isDeep = flag(this, "deep"), descriptor = isDeep ? "deep " : "", isEql = isDeep ? flag(this, "eql") : SameValueZero; + flagMsg = flagMsg ? flagMsg + ": " : ""; + var included = false; + switch (objType) { + case "string": + included = obj.indexOf(val) !== -1; + break; + case "weakset": + if (isDeep) { + throw new AssertionError2( + flagMsg + "unable to use .deep.include with WeakSet", + void 0, + ssfi + ); + } + included = obj.has(val); + break; + case "map": + obj.forEach(function(item) { + included = included || isEql(item, val); + }); + break; + case "set": + if (isDeep) { + obj.forEach(function(item) { + included = included || isEql(item, val); + }); + } else { + included = obj.has(val); + } + break; + case "array": + if (isDeep) { + included = obj.some(function(item) { + return isEql(item, val); + }); + } else { + included = obj.indexOf(val) !== -1; + } + break; + default: + if (val !== Object(val)) { + throw new AssertionError2( + flagMsg + "the given combination of arguments (" + objType + " and " + _.type(val).toLowerCase() + ") is invalid for this assertion. You can use an array, a map, an object, a set, a string, or a weakset instead of a " + _.type(val).toLowerCase(), + void 0, + ssfi + ); + } + var props = Object.keys(val), firstErr = null, numErrs = 0; + props.forEach(function(prop) { + var propAssertion = new Assertion2(obj); + _.transferFlags(this, propAssertion, true); + flag(propAssertion, "lockSsfi", true); + if (!negate || props.length === 1) { + propAssertion.property(prop, val[prop]); + return; + } + try { + propAssertion.property(prop, val[prop]); + } catch (err) { + if (!_.checkError.compatibleConstructor(err, AssertionError2)) { + throw err; + } + if (firstErr === null) + firstErr = err; + numErrs++; + } + }, this); + if (negate && props.length > 1 && numErrs === props.length) { + throw firstErr; + } + return; + } + this.assert( + included, + "expected #{this} to " + descriptor + "include " + _.inspect(val), + "expected #{this} to not " + descriptor + "include " + _.inspect(val) + ); + } + Assertion2.addChainableMethod("include", include, includeChainingBehavior); + Assertion2.addChainableMethod("contain", include, includeChainingBehavior); + Assertion2.addChainableMethod("contains", include, includeChainingBehavior); + Assertion2.addChainableMethod("includes", include, includeChainingBehavior); + Assertion2.addProperty("ok", function() { + this.assert( + flag(this, "object"), + "expected #{this} to be truthy", + "expected #{this} to be falsy" + ); + }); + Assertion2.addProperty("true", function() { + this.assert( + true === flag(this, "object"), + "expected #{this} to be true", + "expected #{this} to be false", + flag(this, "negate") ? false : true + ); + }); + Assertion2.addProperty("false", function() { + this.assert( + false === flag(this, "object"), + "expected #{this} to be false", + "expected #{this} to be true", + flag(this, "negate") ? true : false + ); + }); + Assertion2.addProperty("null", function() { + this.assert( + null === flag(this, "object"), + "expected #{this} to be null", + "expected #{this} not to be null" + ); + }); + Assertion2.addProperty("undefined", function() { + this.assert( + void 0 === flag(this, "object"), + "expected #{this} to be undefined", + "expected #{this} not to be undefined" + ); + }); + Assertion2.addProperty("NaN", function() { + this.assert( + _.isNaN(flag(this, "object")), + "expected #{this} to be NaN", + "expected #{this} not to be NaN" + ); + }); + function assertExist() { + var val = flag(this, "object"); + this.assert( + val !== null && val !== void 0, + "expected #{this} to exist", + "expected #{this} to not exist" + ); + } + Assertion2.addProperty("exist", assertExist); + Assertion2.addProperty("exists", assertExist); + Assertion2.addProperty("empty", function() { + var val = flag(this, "object"), ssfi = flag(this, "ssfi"), flagMsg = flag(this, "message"), itemsCount; + flagMsg = flagMsg ? flagMsg + ": " : ""; + switch (_.type(val).toLowerCase()) { + case "array": + case "string": + itemsCount = val.length; + break; + case "map": + case "set": + itemsCount = val.size; + break; + case "weakmap": + case "weakset": + throw new AssertionError2( + flagMsg + ".empty was passed a weak collection", + void 0, + ssfi + ); + case "function": + var msg = flagMsg + ".empty was passed a function " + _.getName(val); + throw new AssertionError2(msg.trim(), void 0, ssfi); + default: + if (val !== Object(val)) { + throw new AssertionError2( + flagMsg + ".empty was passed non-string primitive " + _.inspect(val), + void 0, + ssfi + ); + } + itemsCount = Object.keys(val).length; + } + this.assert( + 0 === itemsCount, + "expected #{this} to be empty", + "expected #{this} not to be empty" + ); + }); + function checkArguments() { + var obj = flag(this, "object"), type = _.type(obj); + this.assert( + "Arguments" === type, + "expected #{this} to be arguments but got " + type, + "expected #{this} to not be arguments" + ); + } + Assertion2.addProperty("arguments", checkArguments); + Assertion2.addProperty("Arguments", checkArguments); + function assertEqual(val, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"); + if (flag(this, "deep")) { + var prevLockSsfi = flag(this, "lockSsfi"); + flag(this, "lockSsfi", true); + this.eql(val); + flag(this, "lockSsfi", prevLockSsfi); + } else { + this.assert( + val === obj, + "expected #{this} to equal #{exp}", + "expected #{this} to not equal #{exp}", + val, + this._obj, + true + ); + } + } + Assertion2.addMethod("equal", assertEqual); + Assertion2.addMethod("equals", assertEqual); + Assertion2.addMethod("eq", assertEqual); + function assertEql(obj, msg) { + if (msg) + flag(this, "message", msg); + var eql = flag(this, "eql"); + this.assert( + eql(obj, flag(this, "object")), + "expected #{this} to deeply equal #{exp}", + "expected #{this} to not deeply equal #{exp}", + obj, + this._obj, + true + ); + } + Assertion2.addMethod("eql", assertEql); + Assertion2.addMethod("eqls", assertEql); + function assertAbove(n, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), doLength = flag(this, "doLength"), flagMsg = flag(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag(this, "ssfi"), objType = _.type(obj).toLowerCase(), nType = _.type(n).toLowerCase(), errorMessage, shouldThrow = true; + if (doLength && objType !== "map" && objType !== "set") { + new Assertion2(obj, flagMsg, ssfi, true).to.have.property("length"); + } + if (!doLength && (objType === "date" && nType !== "date")) { + errorMessage = msgPrefix + "the argument to above must be a date"; + } else if (nType !== "number" && (doLength || objType === "number")) { + errorMessage = msgPrefix + "the argument to above must be a number"; + } else if (!doLength && (objType !== "date" && objType !== "number")) { + var printObj = objType === "string" ? "'" + obj + "'" : obj; + errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date"; + } else { + shouldThrow = false; + } + if (shouldThrow) { + throw new AssertionError2(errorMessage, void 0, ssfi); + } + if (doLength) { + var descriptor = "length", itemsCount; + if (objType === "map" || objType === "set") { + descriptor = "size"; + itemsCount = obj.size; + } else { + itemsCount = obj.length; + } + this.assert( + itemsCount > n, + "expected #{this} to have a " + descriptor + " above #{exp} but got #{act}", + "expected #{this} to not have a " + descriptor + " above #{exp}", + n, + itemsCount + ); + } else { + this.assert( + obj > n, + "expected #{this} to be above #{exp}", + "expected #{this} to be at most #{exp}", + n + ); + } + } + Assertion2.addMethod("above", assertAbove); + Assertion2.addMethod("gt", assertAbove); + Assertion2.addMethod("greaterThan", assertAbove); + function assertLeast(n, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), doLength = flag(this, "doLength"), flagMsg = flag(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag(this, "ssfi"), objType = _.type(obj).toLowerCase(), nType = _.type(n).toLowerCase(), errorMessage, shouldThrow = true; + if (doLength && objType !== "map" && objType !== "set") { + new Assertion2(obj, flagMsg, ssfi, true).to.have.property("length"); + } + if (!doLength && (objType === "date" && nType !== "date")) { + errorMessage = msgPrefix + "the argument to least must be a date"; + } else if (nType !== "number" && (doLength || objType === "number")) { + errorMessage = msgPrefix + "the argument to least must be a number"; + } else if (!doLength && (objType !== "date" && objType !== "number")) { + var printObj = objType === "string" ? "'" + obj + "'" : obj; + errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date"; + } else { + shouldThrow = false; + } + if (shouldThrow) { + throw new AssertionError2(errorMessage, void 0, ssfi); + } + if (doLength) { + var descriptor = "length", itemsCount; + if (objType === "map" || objType === "set") { + descriptor = "size"; + itemsCount = obj.size; + } else { + itemsCount = obj.length; + } + this.assert( + itemsCount >= n, + "expected #{this} to have a " + descriptor + " at least #{exp} but got #{act}", + "expected #{this} to have a " + descriptor + " below #{exp}", + n, + itemsCount + ); + } else { + this.assert( + obj >= n, + "expected #{this} to be at least #{exp}", + "expected #{this} to be below #{exp}", + n + ); + } + } + Assertion2.addMethod("least", assertLeast); + Assertion2.addMethod("gte", assertLeast); + Assertion2.addMethod("greaterThanOrEqual", assertLeast); + function assertBelow(n, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), doLength = flag(this, "doLength"), flagMsg = flag(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag(this, "ssfi"), objType = _.type(obj).toLowerCase(), nType = _.type(n).toLowerCase(), errorMessage, shouldThrow = true; + if (doLength && objType !== "map" && objType !== "set") { + new Assertion2(obj, flagMsg, ssfi, true).to.have.property("length"); + } + if (!doLength && (objType === "date" && nType !== "date")) { + errorMessage = msgPrefix + "the argument to below must be a date"; + } else if (nType !== "number" && (doLength || objType === "number")) { + errorMessage = msgPrefix + "the argument to below must be a number"; + } else if (!doLength && (objType !== "date" && objType !== "number")) { + var printObj = objType === "string" ? "'" + obj + "'" : obj; + errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date"; + } else { + shouldThrow = false; + } + if (shouldThrow) { + throw new AssertionError2(errorMessage, void 0, ssfi); + } + if (doLength) { + var descriptor = "length", itemsCount; + if (objType === "map" || objType === "set") { + descriptor = "size"; + itemsCount = obj.size; + } else { + itemsCount = obj.length; + } + this.assert( + itemsCount < n, + "expected #{this} to have a " + descriptor + " below #{exp} but got #{act}", + "expected #{this} to not have a " + descriptor + " below #{exp}", + n, + itemsCount + ); + } else { + this.assert( + obj < n, + "expected #{this} to be below #{exp}", + "expected #{this} to be at least #{exp}", + n + ); + } + } + Assertion2.addMethod("below", assertBelow); + Assertion2.addMethod("lt", assertBelow); + Assertion2.addMethod("lessThan", assertBelow); + function assertMost(n, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), doLength = flag(this, "doLength"), flagMsg = flag(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag(this, "ssfi"), objType = _.type(obj).toLowerCase(), nType = _.type(n).toLowerCase(), errorMessage, shouldThrow = true; + if (doLength && objType !== "map" && objType !== "set") { + new Assertion2(obj, flagMsg, ssfi, true).to.have.property("length"); + } + if (!doLength && (objType === "date" && nType !== "date")) { + errorMessage = msgPrefix + "the argument to most must be a date"; + } else if (nType !== "number" && (doLength || objType === "number")) { + errorMessage = msgPrefix + "the argument to most must be a number"; + } else if (!doLength && (objType !== "date" && objType !== "number")) { + var printObj = objType === "string" ? "'" + obj + "'" : obj; + errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date"; + } else { + shouldThrow = false; + } + if (shouldThrow) { + throw new AssertionError2(errorMessage, void 0, ssfi); + } + if (doLength) { + var descriptor = "length", itemsCount; + if (objType === "map" || objType === "set") { + descriptor = "size"; + itemsCount = obj.size; + } else { + itemsCount = obj.length; + } + this.assert( + itemsCount <= n, + "expected #{this} to have a " + descriptor + " at most #{exp} but got #{act}", + "expected #{this} to have a " + descriptor + " above #{exp}", + n, + itemsCount + ); + } else { + this.assert( + obj <= n, + "expected #{this} to be at most #{exp}", + "expected #{this} to be above #{exp}", + n + ); + } + } + Assertion2.addMethod("most", assertMost); + Assertion2.addMethod("lte", assertMost); + Assertion2.addMethod("lessThanOrEqual", assertMost); + Assertion2.addMethod("within", function(start, finish, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), doLength = flag(this, "doLength"), flagMsg = flag(this, "message"), msgPrefix = flagMsg ? flagMsg + ": " : "", ssfi = flag(this, "ssfi"), objType = _.type(obj).toLowerCase(), startType = _.type(start).toLowerCase(), finishType = _.type(finish).toLowerCase(), errorMessage, shouldThrow = true, range = startType === "date" && finishType === "date" ? start.toISOString() + ".." + finish.toISOString() : start + ".." + finish; + if (doLength && objType !== "map" && objType !== "set") { + new Assertion2(obj, flagMsg, ssfi, true).to.have.property("length"); + } + if (!doLength && (objType === "date" && (startType !== "date" || finishType !== "date"))) { + errorMessage = msgPrefix + "the arguments to within must be dates"; + } else if ((startType !== "number" || finishType !== "number") && (doLength || objType === "number")) { + errorMessage = msgPrefix + "the arguments to within must be numbers"; + } else if (!doLength && (objType !== "date" && objType !== "number")) { + var printObj = objType === "string" ? "'" + obj + "'" : obj; + errorMessage = msgPrefix + "expected " + printObj + " to be a number or a date"; + } else { + shouldThrow = false; + } + if (shouldThrow) { + throw new AssertionError2(errorMessage, void 0, ssfi); + } + if (doLength) { + var descriptor = "length", itemsCount; + if (objType === "map" || objType === "set") { + descriptor = "size"; + itemsCount = obj.size; + } else { + itemsCount = obj.length; + } + this.assert( + itemsCount >= start && itemsCount <= finish, + "expected #{this} to have a " + descriptor + " within " + range, + "expected #{this} to not have a " + descriptor + " within " + range + ); + } else { + this.assert( + obj >= start && obj <= finish, + "expected #{this} to be within " + range, + "expected #{this} to not be within " + range + ); + } + }); + function assertInstanceOf(constructor, msg) { + if (msg) + flag(this, "message", msg); + var target = flag(this, "object"); + var ssfi = flag(this, "ssfi"); + var flagMsg = flag(this, "message"); + try { + var isInstanceOf = target instanceof constructor; + } catch (err) { + if (err instanceof TypeError) { + flagMsg = flagMsg ? flagMsg + ": " : ""; + throw new AssertionError2( + flagMsg + "The instanceof assertion needs a constructor but " + _.type(constructor) + " was given.", + void 0, + ssfi + ); + } + throw err; + } + var name = _.getName(constructor); + if (name === null) { + name = "an unnamed constructor"; + } + this.assert( + isInstanceOf, + "expected #{this} to be an instance of " + name, + "expected #{this} to not be an instance of " + name + ); + } + ; + Assertion2.addMethod("instanceof", assertInstanceOf); + Assertion2.addMethod("instanceOf", assertInstanceOf); + function assertProperty(name, val, msg) { + if (msg) + flag(this, "message", msg); + var isNested = flag(this, "nested"), isOwn = flag(this, "own"), flagMsg = flag(this, "message"), obj = flag(this, "object"), ssfi = flag(this, "ssfi"), nameType = typeof name; + flagMsg = flagMsg ? flagMsg + ": " : ""; + if (isNested) { + if (nameType !== "string") { + throw new AssertionError2( + flagMsg + "the argument to property must be a string when using nested syntax", + void 0, + ssfi + ); + } + } else { + if (nameType !== "string" && nameType !== "number" && nameType !== "symbol") { + throw new AssertionError2( + flagMsg + "the argument to property must be a string, number, or symbol", + void 0, + ssfi + ); + } + } + if (isNested && isOwn) { + throw new AssertionError2( + flagMsg + 'The "nested" and "own" flags cannot be combined.', + void 0, + ssfi + ); + } + if (obj === null || obj === void 0) { + throw new AssertionError2( + flagMsg + "Target cannot be null or undefined.", + void 0, + ssfi + ); + } + var isDeep = flag(this, "deep"), negate = flag(this, "negate"), pathInfo = isNested ? _.getPathInfo(obj, name) : null, value = isNested ? pathInfo.value : obj[name], isEql = isDeep ? flag(this, "eql") : (val1, val2) => val1 === val2; + ; + var descriptor = ""; + if (isDeep) + descriptor += "deep "; + if (isOwn) + descriptor += "own "; + if (isNested) + descriptor += "nested "; + descriptor += "property "; + var hasProperty; + if (isOwn) + hasProperty = Object.prototype.hasOwnProperty.call(obj, name); + else if (isNested) + hasProperty = pathInfo.exists; + else + hasProperty = _.hasProperty(obj, name); + if (!negate || arguments.length === 1) { + this.assert( + hasProperty, + "expected #{this} to have " + descriptor + _.inspect(name), + "expected #{this} to not have " + descriptor + _.inspect(name) + ); + } + if (arguments.length > 1) { + this.assert( + hasProperty && isEql(val, value), + "expected #{this} to have " + descriptor + _.inspect(name) + " of #{exp}, but got #{act}", + "expected #{this} to not have " + descriptor + _.inspect(name) + " of #{act}", + val, + value + ); + } + flag(this, "object", value); + } + Assertion2.addMethod("property", assertProperty); + function assertOwnProperty(name, value, msg) { + flag(this, "own", true); + assertProperty.apply(this, arguments); + } + Assertion2.addMethod("ownProperty", assertOwnProperty); + Assertion2.addMethod("haveOwnProperty", assertOwnProperty); + function assertOwnPropertyDescriptor(name, descriptor, msg) { + if (typeof descriptor === "string") { + msg = descriptor; + descriptor = null; + } + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"); + var actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name); + var eql = flag(this, "eql"); + if (actualDescriptor && descriptor) { + this.assert( + eql(descriptor, actualDescriptor), + "expected the own property descriptor for " + _.inspect(name) + " on #{this} to match " + _.inspect(descriptor) + ", got " + _.inspect(actualDescriptor), + "expected the own property descriptor for " + _.inspect(name) + " on #{this} to not match " + _.inspect(descriptor), + descriptor, + actualDescriptor, + true + ); + } else { + this.assert( + actualDescriptor, + "expected #{this} to have an own property descriptor for " + _.inspect(name), + "expected #{this} to not have an own property descriptor for " + _.inspect(name) + ); + } + flag(this, "object", actualDescriptor); + } + Assertion2.addMethod("ownPropertyDescriptor", assertOwnPropertyDescriptor); + Assertion2.addMethod("haveOwnPropertyDescriptor", assertOwnPropertyDescriptor); + function assertLengthChain() { + flag(this, "doLength", true); + } + function assertLength(n, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), objType = _.type(obj).toLowerCase(), flagMsg = flag(this, "message"), ssfi = flag(this, "ssfi"), descriptor = "length", itemsCount; + switch (objType) { + case "map": + case "set": + descriptor = "size"; + itemsCount = obj.size; + break; + default: + new Assertion2(obj, flagMsg, ssfi, true).to.have.property("length"); + itemsCount = obj.length; + } + this.assert( + itemsCount == n, + "expected #{this} to have a " + descriptor + " of #{exp} but got #{act}", + "expected #{this} to not have a " + descriptor + " of #{act}", + n, + itemsCount + ); + } + Assertion2.addChainableMethod("length", assertLength, assertLengthChain); + Assertion2.addChainableMethod("lengthOf", assertLength, assertLengthChain); + function assertMatch(re, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"); + this.assert( + re.exec(obj), + "expected #{this} to match " + re, + "expected #{this} not to match " + re + ); + } + Assertion2.addMethod("match", assertMatch); + Assertion2.addMethod("matches", assertMatch); + Assertion2.addMethod("string", function(str, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), flagMsg = flag(this, "message"), ssfi = flag(this, "ssfi"); + new Assertion2(obj, flagMsg, ssfi, true).is.a("string"); + this.assert( + ~obj.indexOf(str), + "expected #{this} to contain " + _.inspect(str), + "expected #{this} to not contain " + _.inspect(str) + ); + }); + function assertKeys(keys) { + var obj = flag(this, "object"), objType = _.type(obj), keysType = _.type(keys), ssfi = flag(this, "ssfi"), isDeep = flag(this, "deep"), str, deepStr = "", actual, ok = true, flagMsg = flag(this, "message"); + flagMsg = flagMsg ? flagMsg + ": " : ""; + var mixedArgsMsg = flagMsg + "when testing keys against an object or an array you must give a single Array|Object|String argument or multiple String arguments"; + if (objType === "Map" || objType === "Set") { + deepStr = isDeep ? "deeply " : ""; + actual = []; + obj.forEach(function(val, key) { + actual.push(key); + }); + if (keysType !== "Array") { + keys = Array.prototype.slice.call(arguments); + } + } else { + actual = _.getOwnEnumerableProperties(obj); + switch (keysType) { + case "Array": + if (arguments.length > 1) { + throw new AssertionError2(mixedArgsMsg, void 0, ssfi); + } + break; + case "Object": + if (arguments.length > 1) { + throw new AssertionError2(mixedArgsMsg, void 0, ssfi); + } + keys = Object.keys(keys); + break; + default: + keys = Array.prototype.slice.call(arguments); + } + keys = keys.map(function(val) { + return typeof val === "symbol" ? val : String(val); + }); + } + if (!keys.length) { + throw new AssertionError2(flagMsg + "keys required", void 0, ssfi); + } + var len = keys.length, any = flag(this, "any"), all = flag(this, "all"), expected = keys, isEql = isDeep ? flag(this, "eql") : (val1, val2) => val1 === val2; + if (!any && !all) { + all = true; + } + if (any) { + ok = expected.some(function(expectedKey) { + return actual.some(function(actualKey) { + return isEql(expectedKey, actualKey); + }); + }); + } + if (all) { + ok = expected.every(function(expectedKey) { + return actual.some(function(actualKey) { + return isEql(expectedKey, actualKey); + }); + }); + if (!flag(this, "contains")) { + ok = ok && keys.length == actual.length; + } + } + if (len > 1) { + keys = keys.map(function(key) { + return _.inspect(key); + }); + var last = keys.pop(); + if (all) { + str = keys.join(", ") + ", and " + last; + } + if (any) { + str = keys.join(", ") + ", or " + last; + } + } else { + str = _.inspect(keys[0]); + } + str = (len > 1 ? "keys " : "key ") + str; + str = (flag(this, "contains") ? "contain " : "have ") + str; + this.assert( + ok, + "expected #{this} to " + deepStr + str, + "expected #{this} to not " + deepStr + str, + expected.slice(0).sort(_.compareByInspect), + actual.sort(_.compareByInspect), + true + ); + } + Assertion2.addMethod("keys", assertKeys); + Assertion2.addMethod("key", assertKeys); + function assertThrows(errorLike, errMsgMatcher, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), ssfi = flag(this, "ssfi"), flagMsg = flag(this, "message"), negate = flag(this, "negate") || false; + new Assertion2(obj, flagMsg, ssfi, true).is.a("function"); + if (errorLike instanceof RegExp || typeof errorLike === "string") { + errMsgMatcher = errorLike; + errorLike = null; + } + var caughtErr; + try { + obj(); + } catch (err) { + caughtErr = err; + } + var everyArgIsUndefined = errorLike === void 0 && errMsgMatcher === void 0; + var everyArgIsDefined = Boolean(errorLike && errMsgMatcher); + var errorLikeFail = false; + var errMsgMatcherFail = false; + if (everyArgIsUndefined || !everyArgIsUndefined && !negate) { + var errorLikeString = "an error"; + if (errorLike instanceof Error) { + errorLikeString = "#{exp}"; + } else if (errorLike) { + errorLikeString = _.checkError.getConstructorName(errorLike); + } + this.assert( + caughtErr, + "expected #{this} to throw " + errorLikeString, + "expected #{this} to not throw an error but #{act} was thrown", + errorLike && errorLike.toString(), + caughtErr instanceof Error ? caughtErr.toString() : typeof caughtErr === "string" ? caughtErr : caughtErr && _.checkError.getConstructorName(caughtErr) + ); + } + if (errorLike && caughtErr) { + if (errorLike instanceof Error) { + var isCompatibleInstance = _.checkError.compatibleInstance(caughtErr, errorLike); + if (isCompatibleInstance === negate) { + if (everyArgIsDefined && negate) { + errorLikeFail = true; + } else { + this.assert( + negate, + "expected #{this} to throw #{exp} but #{act} was thrown", + "expected #{this} to not throw #{exp}" + (caughtErr && !negate ? " but #{act} was thrown" : ""), + errorLike.toString(), + caughtErr.toString() + ); + } + } + } + var isCompatibleConstructor = _.checkError.compatibleConstructor(caughtErr, errorLike); + if (isCompatibleConstructor === negate) { + if (everyArgIsDefined && negate) { + errorLikeFail = true; + } else { + this.assert( + negate, + "expected #{this} to throw #{exp} but #{act} was thrown", + "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""), + errorLike instanceof Error ? errorLike.toString() : errorLike && _.checkError.getConstructorName(errorLike), + caughtErr instanceof Error ? caughtErr.toString() : caughtErr && _.checkError.getConstructorName(caughtErr) + ); + } + } + } + if (caughtErr && errMsgMatcher !== void 0 && errMsgMatcher !== null) { + var placeholder = "including"; + if (errMsgMatcher instanceof RegExp) { + placeholder = "matching"; + } + var isCompatibleMessage = _.checkError.compatibleMessage(caughtErr, errMsgMatcher); + if (isCompatibleMessage === negate) { + if (everyArgIsDefined && negate) { + errMsgMatcherFail = true; + } else { + this.assert( + negate, + "expected #{this} to throw error " + placeholder + " #{exp} but got #{act}", + "expected #{this} to throw error not " + placeholder + " #{exp}", + errMsgMatcher, + _.checkError.getMessage(caughtErr) + ); + } + } + } + if (errorLikeFail && errMsgMatcherFail) { + this.assert( + negate, + "expected #{this} to throw #{exp} but #{act} was thrown", + "expected #{this} to not throw #{exp}" + (caughtErr ? " but #{act} was thrown" : ""), + errorLike instanceof Error ? errorLike.toString() : errorLike && _.checkError.getConstructorName(errorLike), + caughtErr instanceof Error ? caughtErr.toString() : caughtErr && _.checkError.getConstructorName(caughtErr) + ); + } + flag(this, "object", caughtErr); + } + ; + Assertion2.addMethod("throw", assertThrows); + Assertion2.addMethod("throws", assertThrows); + Assertion2.addMethod("Throw", assertThrows); + function respondTo(method, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), itself = flag(this, "itself"), context = "function" === typeof obj && !itself ? obj.prototype[method] : obj[method]; + this.assert( + "function" === typeof context, + "expected #{this} to respond to " + _.inspect(method), + "expected #{this} to not respond to " + _.inspect(method) + ); + } + Assertion2.addMethod("respondTo", respondTo); + Assertion2.addMethod("respondsTo", respondTo); + Assertion2.addProperty("itself", function() { + flag(this, "itself", true); + }); + function satisfy(matcher, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"); + var result = matcher(obj); + this.assert( + result, + "expected #{this} to satisfy " + _.objDisplay(matcher), + "expected #{this} to not satisfy" + _.objDisplay(matcher), + flag(this, "negate") ? false : true, + result + ); + } + Assertion2.addMethod("satisfy", satisfy); + Assertion2.addMethod("satisfies", satisfy); + function closeTo(expected, delta, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), flagMsg = flag(this, "message"), ssfi = flag(this, "ssfi"); + new Assertion2(obj, flagMsg, ssfi, true).is.a("number"); + if (typeof expected !== "number" || typeof delta !== "number") { + flagMsg = flagMsg ? flagMsg + ": " : ""; + var deltaMessage = delta === void 0 ? ", and a delta is required" : ""; + throw new AssertionError2( + flagMsg + "the arguments to closeTo or approximately must be numbers" + deltaMessage, + void 0, + ssfi + ); + } + this.assert( + Math.abs(obj - expected) <= delta, + "expected #{this} to be close to " + expected + " +/- " + delta, + "expected #{this} not to be close to " + expected + " +/- " + delta + ); + } + Assertion2.addMethod("closeTo", closeTo); + Assertion2.addMethod("approximately", closeTo); + function isSubsetOf(subset, superset, cmp, contains, ordered) { + if (!contains) { + if (subset.length !== superset.length) + return false; + superset = superset.slice(); + } + return subset.every(function(elem, idx) { + if (ordered) + return cmp ? cmp(elem, superset[idx]) : elem === superset[idx]; + if (!cmp) { + var matchIdx = superset.indexOf(elem); + if (matchIdx === -1) + return false; + if (!contains) + superset.splice(matchIdx, 1); + return true; + } + return superset.some(function(elem2, matchIdx2) { + if (!cmp(elem, elem2)) + return false; + if (!contains) + superset.splice(matchIdx2, 1); + return true; + }); + }); + } + Assertion2.addMethod("members", function(subset, msg) { + if (msg) + flag(this, "message", msg); + var obj = flag(this, "object"), flagMsg = flag(this, "message"), ssfi = flag(this, "ssfi"); + new Assertion2(obj, flagMsg, ssfi, true).to.be.an("array"); + new Assertion2(subset, flagMsg, ssfi, true).to.be.an("array"); + var contains = flag(this, "contains"); + var ordered = flag(this, "ordered"); + var subject, failMsg, failNegateMsg; + if (contains) { + subject = ordered ? "an ordered superset" : "a superset"; + failMsg = "expected #{this} to be " + subject + " of #{exp}"; + failNegateMsg = "expected #{this} to not be " + subject + " of #{exp}"; + } else { + subject = ordered ? "ordered members" : "members"; + failMsg = "expected #{this} to have the same " + subject + " as #{exp}"; + failNegateMsg = "expected #{this} to not have the same " + subject + " as #{exp}"; + } + var cmp = flag(this, "deep") ? flag(this, "eql") : void 0; + this.assert( + isSubsetOf(subset, obj, cmp, contains, ordered), + failMsg, + failNegateMsg, + subset, + obj, + true + ); + }); + function oneOf(list, msg) { + if (msg) + flag(this, "message", msg); + var expected = flag(this, "object"), flagMsg = flag(this, "message"), ssfi = flag(this, "ssfi"), contains = flag(this, "contains"), isDeep = flag(this, "deep"), eql = flag(this, "eql"); + new Assertion2(list, flagMsg, ssfi, true).to.be.an("array"); + if (contains) { + this.assert( + list.some(function(possibility) { + return expected.indexOf(possibility) > -1; + }), + "expected #{this} to contain one of #{exp}", + "expected #{this} to not contain one of #{exp}", + list, + expected + ); + } else { + if (isDeep) { + this.assert( + list.some(function(possibility) { + return eql(expected, possibility); + }), + "expected #{this} to deeply equal one of #{exp}", + "expected #{this} to deeply equal one of #{exp}", + list, + expected + ); + } else { + this.assert( + list.indexOf(expected) > -1, + "expected #{this} to be one of #{exp}", + "expected #{this} to not be one of #{exp}", + list, + expected + ); + } + } + } + Assertion2.addMethod("oneOf", oneOf); + function assertChanges(subject, prop, msg) { + if (msg) + flag(this, "message", msg); + var fn = flag(this, "object"), flagMsg = flag(this, "message"), ssfi = flag(this, "ssfi"); + new Assertion2(fn, flagMsg, ssfi, true).is.a("function"); + var initial; + if (!prop) { + new Assertion2(subject, flagMsg, ssfi, true).is.a("function"); + initial = subject(); + } else { + new Assertion2(subject, flagMsg, ssfi, true).to.have.property(prop); + initial = subject[prop]; + } + fn(); + var final = prop === void 0 || prop === null ? subject() : subject[prop]; + var msgObj = prop === void 0 || prop === null ? initial : "." + prop; + flag(this, "deltaMsgObj", msgObj); + flag(this, "initialDeltaValue", initial); + flag(this, "finalDeltaValue", final); + flag(this, "deltaBehavior", "change"); + flag(this, "realDelta", final !== initial); + this.assert( + initial !== final, + "expected " + msgObj + " to change", + "expected " + msgObj + " to not change" + ); + } + Assertion2.addMethod("change", assertChanges); + Assertion2.addMethod("changes", assertChanges); + function assertIncreases(subject, prop, msg) { + if (msg) + flag(this, "message", msg); + var fn = flag(this, "object"), flagMsg = flag(this, "message"), ssfi = flag(this, "ssfi"); + new Assertion2(fn, flagMsg, ssfi, true).is.a("function"); + var initial; + if (!prop) { + new Assertion2(subject, flagMsg, ssfi, true).is.a("function"); + initial = subject(); + } else { + new Assertion2(subject, flagMsg, ssfi, true).to.have.property(prop); + initial = subject[prop]; + } + new Assertion2(initial, flagMsg, ssfi, true).is.a("number"); + fn(); + var final = prop === void 0 || prop === null ? subject() : subject[prop]; + var msgObj = prop === void 0 || prop === null ? initial : "." + prop; + flag(this, "deltaMsgObj", msgObj); + flag(this, "initialDeltaValue", initial); + flag(this, "finalDeltaValue", final); + flag(this, "deltaBehavior", "increase"); + flag(this, "realDelta", final - initial); + this.assert( + final - initial > 0, + "expected " + msgObj + " to increase", + "expected " + msgObj + " to not increase" + ); + } + Assertion2.addMethod("increase", assertIncreases); + Assertion2.addMethod("increases", assertIncreases); + function assertDecreases(subject, prop, msg) { + if (msg) + flag(this, "message", msg); + var fn = flag(this, "object"), flagMsg = flag(this, "message"), ssfi = flag(this, "ssfi"); + new Assertion2(fn, flagMsg, ssfi, true).is.a("function"); + var initial; + if (!prop) { + new Assertion2(subject, flagMsg, ssfi, true).is.a("function"); + initial = subject(); + } else { + new Assertion2(subject, flagMsg, ssfi, true).to.have.property(prop); + initial = subject[prop]; + } + new Assertion2(initial, flagMsg, ssfi, true).is.a("number"); + fn(); + var final = prop === void 0 || prop === null ? subject() : subject[prop]; + var msgObj = prop === void 0 || prop === null ? initial : "." + prop; + flag(this, "deltaMsgObj", msgObj); + flag(this, "initialDeltaValue", initial); + flag(this, "finalDeltaValue", final); + flag(this, "deltaBehavior", "decrease"); + flag(this, "realDelta", initial - final); + this.assert( + final - initial < 0, + "expected " + msgObj + " to decrease", + "expected " + msgObj + " to not decrease" + ); + } + Assertion2.addMethod("decrease", assertDecreases); + Assertion2.addMethod("decreases", assertDecreases); + function assertDelta(delta, msg) { + if (msg) + flag(this, "message", msg); + var msgObj = flag(this, "deltaMsgObj"); + var initial = flag(this, "initialDeltaValue"); + var final = flag(this, "finalDeltaValue"); + var behavior = flag(this, "deltaBehavior"); + var realDelta = flag(this, "realDelta"); + var expression; + if (behavior === "change") { + expression = Math.abs(final - initial) === Math.abs(delta); + } else { + expression = realDelta === Math.abs(delta); + } + this.assert( + expression, + "expected " + msgObj + " to " + behavior + " by " + delta, + "expected " + msgObj + " to not " + behavior + " by " + delta + ); + } + Assertion2.addMethod("by", assertDelta); + Assertion2.addProperty("extensible", function() { + var obj = flag(this, "object"); + var isExtensible = obj === Object(obj) && Object.isExtensible(obj); + this.assert( + isExtensible, + "expected #{this} to be extensible", + "expected #{this} to not be extensible" + ); + }); + Assertion2.addProperty("sealed", function() { + var obj = flag(this, "object"); + var isSealed = obj === Object(obj) ? Object.isSealed(obj) : true; + this.assert( + isSealed, + "expected #{this} to be sealed", + "expected #{this} to not be sealed" + ); + }); + Assertion2.addProperty("frozen", function() { + var obj = flag(this, "object"); + var isFrozen = obj === Object(obj) ? Object.isFrozen(obj) : true; + this.assert( + isFrozen, + "expected #{this} to be frozen", + "expected #{this} to not be frozen" + ); + }); + Assertion2.addProperty("finite", function(msg) { + var obj = flag(this, "object"); + this.assert( + typeof obj === "number" && isFinite(obj), + "expected #{this} to be a finite number", + "expected #{this} to not be a finite number" + ); + }); + }; + } +}); + +// node_modules/chai/lib/chai/interface/expect.js +var require_expect = __commonJS({ + "node_modules/chai/lib/chai/interface/expect.js"(exports, module) { + init_cjs_shim(); + module.exports = function(chai2, util2) { + chai2.expect = function(val, message) { + return new chai2.Assertion(val, message); + }; + chai2.expect.fail = function(actual, expected, message, operator) { + if (arguments.length < 2) { + message = actual; + actual = void 0; + } + message = message || "expect.fail()"; + throw new chai2.AssertionError(message, { + actual, + expected, + operator + }, chai2.expect.fail); + }; + }; + } +}); + +// node_modules/chai/lib/chai/interface/should.js +var require_should = __commonJS({ + "node_modules/chai/lib/chai/interface/should.js"(exports, module) { + init_cjs_shim(); + module.exports = function(chai2, util2) { + var Assertion2 = chai2.Assertion; + function loadShould() { + function shouldGetter() { + if (this instanceof String || this instanceof Number || this instanceof Boolean || typeof Symbol === "function" && this instanceof Symbol || typeof BigInt === "function" && this instanceof BigInt) { + return new Assertion2(this.valueOf(), null, shouldGetter); + } + return new Assertion2(this, null, shouldGetter); + } + function shouldSetter(value) { + Object.defineProperty(this, "should", { + value, + enumerable: true, + configurable: true, + writable: true + }); + } + Object.defineProperty(Object.prototype, "should", { + set: shouldSetter, + get: shouldGetter, + configurable: true + }); + var should2 = {}; + should2.fail = function(actual, expected, message, operator) { + if (arguments.length < 2) { + message = actual; + actual = void 0; + } + message = message || "should.fail()"; + throw new chai2.AssertionError(message, { + actual, + expected, + operator + }, should2.fail); + }; + should2.equal = function(val1, val2, msg) { + new Assertion2(val1, msg).to.equal(val2); + }; + should2.Throw = function(fn, errt, errs, msg) { + new Assertion2(fn, msg).to.Throw(errt, errs); + }; + should2.exist = function(val, msg) { + new Assertion2(val, msg).to.exist; + }; + should2.not = {}; + should2.not.equal = function(val1, val2, msg) { + new Assertion2(val1, msg).to.not.equal(val2); + }; + should2.not.Throw = function(fn, errt, errs, msg) { + new Assertion2(fn, msg).to.not.Throw(errt, errs); + }; + should2.not.exist = function(val, msg) { + new Assertion2(val, msg).to.not.exist; + }; + should2["throw"] = should2["Throw"]; + should2.not["throw"] = should2.not["Throw"]; + return should2; + } + ; + chai2.should = loadShould; + chai2.Should = loadShould; + }; + } +}); + +// node_modules/chai/lib/chai/interface/assert.js +var require_assert = __commonJS({ + "node_modules/chai/lib/chai/interface/assert.js"(exports, module) { + init_cjs_shim(); + module.exports = function(chai2, util2) { + var Assertion2 = chai2.Assertion, flag = util2.flag; + var assert3 = chai2.assert = function(express, errmsg) { + var test = new Assertion2(null, null, chai2.assert, true); + test.assert( + express, + errmsg, + "[ negation message unavailable ]" + ); + }; + assert3.fail = function(actual, expected, message, operator) { + if (arguments.length < 2) { + message = actual; + actual = void 0; + } + message = message || "assert.fail()"; + throw new chai2.AssertionError(message, { + actual, + expected, + operator + }, assert3.fail); + }; + assert3.isOk = function(val, msg) { + new Assertion2(val, msg, assert3.isOk, true).is.ok; + }; + assert3.isNotOk = function(val, msg) { + new Assertion2(val, msg, assert3.isNotOk, true).is.not.ok; + }; + assert3.equal = function(act, exp, msg) { + var test = new Assertion2(act, msg, assert3.equal, true); + test.assert( + exp == flag(test, "object"), + "expected #{this} to equal #{exp}", + "expected #{this} to not equal #{act}", + exp, + act, + true + ); + }; + assert3.notEqual = function(act, exp, msg) { + var test = new Assertion2(act, msg, assert3.notEqual, true); + test.assert( + exp != flag(test, "object"), + "expected #{this} to not equal #{exp}", + "expected #{this} to equal #{act}", + exp, + act, + true + ); + }; + assert3.strictEqual = function(act, exp, msg) { + new Assertion2(act, msg, assert3.strictEqual, true).to.equal(exp); + }; + assert3.notStrictEqual = function(act, exp, msg) { + new Assertion2(act, msg, assert3.notStrictEqual, true).to.not.equal(exp); + }; + assert3.deepEqual = assert3.deepStrictEqual = function(act, exp, msg) { + new Assertion2(act, msg, assert3.deepEqual, true).to.eql(exp); + }; + assert3.notDeepEqual = function(act, exp, msg) { + new Assertion2(act, msg, assert3.notDeepEqual, true).to.not.eql(exp); + }; + assert3.isAbove = function(val, abv, msg) { + new Assertion2(val, msg, assert3.isAbove, true).to.be.above(abv); + }; + assert3.isAtLeast = function(val, atlst, msg) { + new Assertion2(val, msg, assert3.isAtLeast, true).to.be.least(atlst); + }; + assert3.isBelow = function(val, blw, msg) { + new Assertion2(val, msg, assert3.isBelow, true).to.be.below(blw); + }; + assert3.isAtMost = function(val, atmst, msg) { + new Assertion2(val, msg, assert3.isAtMost, true).to.be.most(atmst); + }; + assert3.isTrue = function(val, msg) { + new Assertion2(val, msg, assert3.isTrue, true).is["true"]; + }; + assert3.isNotTrue = function(val, msg) { + new Assertion2(val, msg, assert3.isNotTrue, true).to.not.equal(true); + }; + assert3.isFalse = function(val, msg) { + new Assertion2(val, msg, assert3.isFalse, true).is["false"]; + }; + assert3.isNotFalse = function(val, msg) { + new Assertion2(val, msg, assert3.isNotFalse, true).to.not.equal(false); + }; + assert3.isNull = function(val, msg) { + new Assertion2(val, msg, assert3.isNull, true).to.equal(null); + }; + assert3.isNotNull = function(val, msg) { + new Assertion2(val, msg, assert3.isNotNull, true).to.not.equal(null); + }; + assert3.isNaN = function(val, msg) { + new Assertion2(val, msg, assert3.isNaN, true).to.be.NaN; + }; + assert3.isNotNaN = function(val, msg) { + new Assertion2(val, msg, assert3.isNotNaN, true).not.to.be.NaN; + }; + assert3.exists = function(val, msg) { + new Assertion2(val, msg, assert3.exists, true).to.exist; + }; + assert3.notExists = function(val, msg) { + new Assertion2(val, msg, assert3.notExists, true).to.not.exist; + }; + assert3.isUndefined = function(val, msg) { + new Assertion2(val, msg, assert3.isUndefined, true).to.equal(void 0); + }; + assert3.isDefined = function(val, msg) { + new Assertion2(val, msg, assert3.isDefined, true).to.not.equal(void 0); + }; + assert3.isFunction = function(val, msg) { + new Assertion2(val, msg, assert3.isFunction, true).to.be.a("function"); + }; + assert3.isNotFunction = function(val, msg) { + new Assertion2(val, msg, assert3.isNotFunction, true).to.not.be.a("function"); + }; + assert3.isObject = function(val, msg) { + new Assertion2(val, msg, assert3.isObject, true).to.be.a("object"); + }; + assert3.isNotObject = function(val, msg) { + new Assertion2(val, msg, assert3.isNotObject, true).to.not.be.a("object"); + }; + assert3.isArray = function(val, msg) { + new Assertion2(val, msg, assert3.isArray, true).to.be.an("array"); + }; + assert3.isNotArray = function(val, msg) { + new Assertion2(val, msg, assert3.isNotArray, true).to.not.be.an("array"); + }; + assert3.isString = function(val, msg) { + new Assertion2(val, msg, assert3.isString, true).to.be.a("string"); + }; + assert3.isNotString = function(val, msg) { + new Assertion2(val, msg, assert3.isNotString, true).to.not.be.a("string"); + }; + assert3.isNumber = function(val, msg) { + new Assertion2(val, msg, assert3.isNumber, true).to.be.a("number"); + }; + assert3.isNotNumber = function(val, msg) { + new Assertion2(val, msg, assert3.isNotNumber, true).to.not.be.a("number"); + }; + assert3.isFinite = function(val, msg) { + new Assertion2(val, msg, assert3.isFinite, true).to.be.finite; + }; + assert3.isBoolean = function(val, msg) { + new Assertion2(val, msg, assert3.isBoolean, true).to.be.a("boolean"); + }; + assert3.isNotBoolean = function(val, msg) { + new Assertion2(val, msg, assert3.isNotBoolean, true).to.not.be.a("boolean"); + }; + assert3.typeOf = function(val, type, msg) { + new Assertion2(val, msg, assert3.typeOf, true).to.be.a(type); + }; + assert3.notTypeOf = function(val, type, msg) { + new Assertion2(val, msg, assert3.notTypeOf, true).to.not.be.a(type); + }; + assert3.instanceOf = function(val, type, msg) { + new Assertion2(val, msg, assert3.instanceOf, true).to.be.instanceOf(type); + }; + assert3.notInstanceOf = function(val, type, msg) { + new Assertion2(val, msg, assert3.notInstanceOf, true).to.not.be.instanceOf(type); + }; + assert3.include = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.include, true).include(inc); + }; + assert3.notInclude = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.notInclude, true).not.include(inc); + }; + assert3.deepInclude = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.deepInclude, true).deep.include(inc); + }; + assert3.notDeepInclude = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.notDeepInclude, true).not.deep.include(inc); + }; + assert3.nestedInclude = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.nestedInclude, true).nested.include(inc); + }; + assert3.notNestedInclude = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.notNestedInclude, true).not.nested.include(inc); + }; + assert3.deepNestedInclude = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.deepNestedInclude, true).deep.nested.include(inc); + }; + assert3.notDeepNestedInclude = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.notDeepNestedInclude, true).not.deep.nested.include(inc); + }; + assert3.ownInclude = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.ownInclude, true).own.include(inc); + }; + assert3.notOwnInclude = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.notOwnInclude, true).not.own.include(inc); + }; + assert3.deepOwnInclude = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.deepOwnInclude, true).deep.own.include(inc); + }; + assert3.notDeepOwnInclude = function(exp, inc, msg) { + new Assertion2(exp, msg, assert3.notDeepOwnInclude, true).not.deep.own.include(inc); + }; + assert3.match = function(exp, re, msg) { + new Assertion2(exp, msg, assert3.match, true).to.match(re); + }; + assert3.notMatch = function(exp, re, msg) { + new Assertion2(exp, msg, assert3.notMatch, true).to.not.match(re); + }; + assert3.property = function(obj, prop, msg) { + new Assertion2(obj, msg, assert3.property, true).to.have.property(prop); + }; + assert3.notProperty = function(obj, prop, msg) { + new Assertion2(obj, msg, assert3.notProperty, true).to.not.have.property(prop); + }; + assert3.propertyVal = function(obj, prop, val, msg) { + new Assertion2(obj, msg, assert3.propertyVal, true).to.have.property(prop, val); + }; + assert3.notPropertyVal = function(obj, prop, val, msg) { + new Assertion2(obj, msg, assert3.notPropertyVal, true).to.not.have.property(prop, val); + }; + assert3.deepPropertyVal = function(obj, prop, val, msg) { + new Assertion2(obj, msg, assert3.deepPropertyVal, true).to.have.deep.property(prop, val); + }; + assert3.notDeepPropertyVal = function(obj, prop, val, msg) { + new Assertion2(obj, msg, assert3.notDeepPropertyVal, true).to.not.have.deep.property(prop, val); + }; + assert3.ownProperty = function(obj, prop, msg) { + new Assertion2(obj, msg, assert3.ownProperty, true).to.have.own.property(prop); + }; + assert3.notOwnProperty = function(obj, prop, msg) { + new Assertion2(obj, msg, assert3.notOwnProperty, true).to.not.have.own.property(prop); + }; + assert3.ownPropertyVal = function(obj, prop, value, msg) { + new Assertion2(obj, msg, assert3.ownPropertyVal, true).to.have.own.property(prop, value); + }; + assert3.notOwnPropertyVal = function(obj, prop, value, msg) { + new Assertion2(obj, msg, assert3.notOwnPropertyVal, true).to.not.have.own.property(prop, value); + }; + assert3.deepOwnPropertyVal = function(obj, prop, value, msg) { + new Assertion2(obj, msg, assert3.deepOwnPropertyVal, true).to.have.deep.own.property(prop, value); + }; + assert3.notDeepOwnPropertyVal = function(obj, prop, value, msg) { + new Assertion2(obj, msg, assert3.notDeepOwnPropertyVal, true).to.not.have.deep.own.property(prop, value); + }; + assert3.nestedProperty = function(obj, prop, msg) { + new Assertion2(obj, msg, assert3.nestedProperty, true).to.have.nested.property(prop); + }; + assert3.notNestedProperty = function(obj, prop, msg) { + new Assertion2(obj, msg, assert3.notNestedProperty, true).to.not.have.nested.property(prop); + }; + assert3.nestedPropertyVal = function(obj, prop, val, msg) { + new Assertion2(obj, msg, assert3.nestedPropertyVal, true).to.have.nested.property(prop, val); + }; + assert3.notNestedPropertyVal = function(obj, prop, val, msg) { + new Assertion2(obj, msg, assert3.notNestedPropertyVal, true).to.not.have.nested.property(prop, val); + }; + assert3.deepNestedPropertyVal = function(obj, prop, val, msg) { + new Assertion2(obj, msg, assert3.deepNestedPropertyVal, true).to.have.deep.nested.property(prop, val); + }; + assert3.notDeepNestedPropertyVal = function(obj, prop, val, msg) { + new Assertion2(obj, msg, assert3.notDeepNestedPropertyVal, true).to.not.have.deep.nested.property(prop, val); + }; + assert3.lengthOf = function(exp, len, msg) { + new Assertion2(exp, msg, assert3.lengthOf, true).to.have.lengthOf(len); + }; + assert3.hasAnyKeys = function(obj, keys, msg) { + new Assertion2(obj, msg, assert3.hasAnyKeys, true).to.have.any.keys(keys); + }; + assert3.hasAllKeys = function(obj, keys, msg) { + new Assertion2(obj, msg, assert3.hasAllKeys, true).to.have.all.keys(keys); + }; + assert3.containsAllKeys = function(obj, keys, msg) { + new Assertion2(obj, msg, assert3.containsAllKeys, true).to.contain.all.keys(keys); + }; + assert3.doesNotHaveAnyKeys = function(obj, keys, msg) { + new Assertion2(obj, msg, assert3.doesNotHaveAnyKeys, true).to.not.have.any.keys(keys); + }; + assert3.doesNotHaveAllKeys = function(obj, keys, msg) { + new Assertion2(obj, msg, assert3.doesNotHaveAllKeys, true).to.not.have.all.keys(keys); + }; + assert3.hasAnyDeepKeys = function(obj, keys, msg) { + new Assertion2(obj, msg, assert3.hasAnyDeepKeys, true).to.have.any.deep.keys(keys); + }; + assert3.hasAllDeepKeys = function(obj, keys, msg) { + new Assertion2(obj, msg, assert3.hasAllDeepKeys, true).to.have.all.deep.keys(keys); + }; + assert3.containsAllDeepKeys = function(obj, keys, msg) { + new Assertion2(obj, msg, assert3.containsAllDeepKeys, true).to.contain.all.deep.keys(keys); + }; + assert3.doesNotHaveAnyDeepKeys = function(obj, keys, msg) { + new Assertion2(obj, msg, assert3.doesNotHaveAnyDeepKeys, true).to.not.have.any.deep.keys(keys); + }; + assert3.doesNotHaveAllDeepKeys = function(obj, keys, msg) { + new Assertion2(obj, msg, assert3.doesNotHaveAllDeepKeys, true).to.not.have.all.deep.keys(keys); + }; + assert3.throws = function(fn, errorLike, errMsgMatcher, msg) { + if ("string" === typeof errorLike || errorLike instanceof RegExp) { + errMsgMatcher = errorLike; + errorLike = null; + } + var assertErr = new Assertion2(fn, msg, assert3.throws, true).to.throw(errorLike, errMsgMatcher); + return flag(assertErr, "object"); + }; + assert3.doesNotThrow = function(fn, errorLike, errMsgMatcher, msg) { + if ("string" === typeof errorLike || errorLike instanceof RegExp) { + errMsgMatcher = errorLike; + errorLike = null; + } + new Assertion2(fn, msg, assert3.doesNotThrow, true).to.not.throw(errorLike, errMsgMatcher); + }; + assert3.operator = function(val, operator, val2, msg) { + var ok; + switch (operator) { + case "==": + ok = val == val2; + break; + case "===": + ok = val === val2; + break; + case ">": + ok = val > val2; + break; + case ">=": + ok = val >= val2; + break; + case "<": + ok = val < val2; + break; + case "<=": + ok = val <= val2; + break; + case "!=": + ok = val != val2; + break; + case "!==": + ok = val !== val2; + break; + default: + msg = msg ? msg + ": " : msg; + throw new chai2.AssertionError( + msg + 'Invalid operator "' + operator + '"', + void 0, + assert3.operator + ); + } + var test = new Assertion2(ok, msg, assert3.operator, true); + test.assert( + true === flag(test, "object"), + "expected " + util2.inspect(val) + " to be " + operator + " " + util2.inspect(val2), + "expected " + util2.inspect(val) + " to not be " + operator + " " + util2.inspect(val2) + ); + }; + assert3.closeTo = function(act, exp, delta, msg) { + new Assertion2(act, msg, assert3.closeTo, true).to.be.closeTo(exp, delta); + }; + assert3.approximately = function(act, exp, delta, msg) { + new Assertion2(act, msg, assert3.approximately, true).to.be.approximately(exp, delta); + }; + assert3.sameMembers = function(set1, set2, msg) { + new Assertion2(set1, msg, assert3.sameMembers, true).to.have.same.members(set2); + }; + assert3.notSameMembers = function(set1, set2, msg) { + new Assertion2(set1, msg, assert3.notSameMembers, true).to.not.have.same.members(set2); + }; + assert3.sameDeepMembers = function(set1, set2, msg) { + new Assertion2(set1, msg, assert3.sameDeepMembers, true).to.have.same.deep.members(set2); + }; + assert3.notSameDeepMembers = function(set1, set2, msg) { + new Assertion2(set1, msg, assert3.notSameDeepMembers, true).to.not.have.same.deep.members(set2); + }; + assert3.sameOrderedMembers = function(set1, set2, msg) { + new Assertion2(set1, msg, assert3.sameOrderedMembers, true).to.have.same.ordered.members(set2); + }; + assert3.notSameOrderedMembers = function(set1, set2, msg) { + new Assertion2(set1, msg, assert3.notSameOrderedMembers, true).to.not.have.same.ordered.members(set2); + }; + assert3.sameDeepOrderedMembers = function(set1, set2, msg) { + new Assertion2(set1, msg, assert3.sameDeepOrderedMembers, true).to.have.same.deep.ordered.members(set2); + }; + assert3.notSameDeepOrderedMembers = function(set1, set2, msg) { + new Assertion2(set1, msg, assert3.notSameDeepOrderedMembers, true).to.not.have.same.deep.ordered.members(set2); + }; + assert3.includeMembers = function(superset, subset, msg) { + new Assertion2(superset, msg, assert3.includeMembers, true).to.include.members(subset); + }; + assert3.notIncludeMembers = function(superset, subset, msg) { + new Assertion2(superset, msg, assert3.notIncludeMembers, true).to.not.include.members(subset); + }; + assert3.includeDeepMembers = function(superset, subset, msg) { + new Assertion2(superset, msg, assert3.includeDeepMembers, true).to.include.deep.members(subset); + }; + assert3.notIncludeDeepMembers = function(superset, subset, msg) { + new Assertion2(superset, msg, assert3.notIncludeDeepMembers, true).to.not.include.deep.members(subset); + }; + assert3.includeOrderedMembers = function(superset, subset, msg) { + new Assertion2(superset, msg, assert3.includeOrderedMembers, true).to.include.ordered.members(subset); + }; + assert3.notIncludeOrderedMembers = function(superset, subset, msg) { + new Assertion2(superset, msg, assert3.notIncludeOrderedMembers, true).to.not.include.ordered.members(subset); + }; + assert3.includeDeepOrderedMembers = function(superset, subset, msg) { + new Assertion2(superset, msg, assert3.includeDeepOrderedMembers, true).to.include.deep.ordered.members(subset); + }; + assert3.notIncludeDeepOrderedMembers = function(superset, subset, msg) { + new Assertion2(superset, msg, assert3.notIncludeDeepOrderedMembers, true).to.not.include.deep.ordered.members(subset); + }; + assert3.oneOf = function(inList, list, msg) { + new Assertion2(inList, msg, assert3.oneOf, true).to.be.oneOf(list); + }; + assert3.changes = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + new Assertion2(fn, msg, assert3.changes, true).to.change(obj, prop); + }; + assert3.changesBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + var tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion2(fn, msg, assert3.changesBy, true).to.change(obj, prop).by(delta); + }; + assert3.doesNotChange = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + return new Assertion2(fn, msg, assert3.doesNotChange, true).to.not.change(obj, prop); + }; + assert3.changesButNotBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + var tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion2(fn, msg, assert3.changesButNotBy, true).to.change(obj, prop).but.not.by(delta); + }; + assert3.increases = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + return new Assertion2(fn, msg, assert3.increases, true).to.increase(obj, prop); + }; + assert3.increasesBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + var tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion2(fn, msg, assert3.increasesBy, true).to.increase(obj, prop).by(delta); + }; + assert3.doesNotIncrease = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + return new Assertion2(fn, msg, assert3.doesNotIncrease, true).to.not.increase(obj, prop); + }; + assert3.increasesButNotBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + var tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion2(fn, msg, assert3.increasesButNotBy, true).to.increase(obj, prop).but.not.by(delta); + }; + assert3.decreases = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + return new Assertion2(fn, msg, assert3.decreases, true).to.decrease(obj, prop); + }; + assert3.decreasesBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + var tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion2(fn, msg, assert3.decreasesBy, true).to.decrease(obj, prop).by(delta); + }; + assert3.doesNotDecrease = function(fn, obj, prop, msg) { + if (arguments.length === 3 && typeof obj === "function") { + msg = prop; + prop = null; + } + return new Assertion2(fn, msg, assert3.doesNotDecrease, true).to.not.decrease(obj, prop); + }; + assert3.doesNotDecreaseBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + var tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + return new Assertion2(fn, msg, assert3.doesNotDecreaseBy, true).to.not.decrease(obj, prop).by(delta); + }; + assert3.decreasesButNotBy = function(fn, obj, prop, delta, msg) { + if (arguments.length === 4 && typeof obj === "function") { + var tmpMsg = delta; + delta = prop; + msg = tmpMsg; + } else if (arguments.length === 3) { + delta = prop; + prop = null; + } + new Assertion2(fn, msg, assert3.decreasesButNotBy, true).to.decrease(obj, prop).but.not.by(delta); + }; + assert3.ifError = function(val) { + if (val) { + throw val; + } + }; + assert3.isExtensible = function(obj, msg) { + new Assertion2(obj, msg, assert3.isExtensible, true).to.be.extensible; + }; + assert3.isNotExtensible = function(obj, msg) { + new Assertion2(obj, msg, assert3.isNotExtensible, true).to.not.be.extensible; + }; + assert3.isSealed = function(obj, msg) { + new Assertion2(obj, msg, assert3.isSealed, true).to.be.sealed; + }; + assert3.isNotSealed = function(obj, msg) { + new Assertion2(obj, msg, assert3.isNotSealed, true).to.not.be.sealed; + }; + assert3.isFrozen = function(obj, msg) { + new Assertion2(obj, msg, assert3.isFrozen, true).to.be.frozen; + }; + assert3.isNotFrozen = function(obj, msg) { + new Assertion2(obj, msg, assert3.isNotFrozen, true).to.not.be.frozen; + }; + assert3.isEmpty = function(val, msg) { + new Assertion2(val, msg, assert3.isEmpty, true).to.be.empty; + }; + assert3.isNotEmpty = function(val, msg) { + new Assertion2(val, msg, assert3.isNotEmpty, true).to.not.be.empty; + }; + (function alias(name, as) { + assert3[as] = assert3[name]; + return alias; + })("isOk", "ok")("isNotOk", "notOk")("throws", "throw")("throws", "Throw")("isExtensible", "extensible")("isNotExtensible", "notExtensible")("isSealed", "sealed")("isNotSealed", "notSealed")("isFrozen", "frozen")("isNotFrozen", "notFrozen")("isEmpty", "empty")("isNotEmpty", "notEmpty"); + }; + } +}); + +// node_modules/chai/lib/chai.js +var require_chai = __commonJS({ + "node_modules/chai/lib/chai.js"(exports) { + init_cjs_shim(); + var used = []; + exports.version = "4.3.8"; + exports.AssertionError = require_assertion_error(); + var util2 = require_utils(); + exports.use = function(fn) { + if (!~used.indexOf(fn)) { + fn(exports, util2); + used.push(fn); + } + return exports; + }; + exports.util = util2; + var config2 = require_config(); + exports.config = config2; + var assertion = require_assertion(); + exports.use(assertion); + var core2 = require_assertions(); + exports.use(core2); + var expect2 = require_expect(); + exports.use(expect2); + var should2 = require_should(); + exports.use(should2); + var assert3 = require_assert(); + exports.use(assert3); + } +}); + +// node_modules/chai/index.js +var require_chai2 = __commonJS({ + "node_modules/chai/index.js"(exports, module) { + init_cjs_shim(); + module.exports = require_chai(); + } +}); + +// ../testeranto/node_modules/semver/internal/constants.js +var require_constants = __commonJS({ + "../testeranto/node_modules/semver/internal/constants.js"(exports, module) { + init_cjs_shim(); + var SEMVER_SPEC_VERSION = "2.0.0"; + var MAX_LENGTH = 256; + var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */ + 9007199254740991; + var MAX_SAFE_COMPONENT_LENGTH = 16; + var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6; + var RELEASE_TYPES = [ + "major", + "premajor", + "minor", + "preminor", + "patch", + "prepatch", + "prerelease" + ]; + module.exports = { + MAX_LENGTH, + MAX_SAFE_COMPONENT_LENGTH, + MAX_SAFE_BUILD_LENGTH, + MAX_SAFE_INTEGER, + RELEASE_TYPES, + SEMVER_SPEC_VERSION, + FLAG_INCLUDE_PRERELEASE: 1, + FLAG_LOOSE: 2 + }; + } +}); + +// ../testeranto/node_modules/semver/internal/debug.js +var require_debug = __commonJS({ + "../testeranto/node_modules/semver/internal/debug.js"(exports, module) { + init_cjs_shim(); + var debug5 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => { + }; + module.exports = debug5; + } +}); + +// ../testeranto/node_modules/semver/internal/re.js +var require_re = __commonJS({ + "../testeranto/node_modules/semver/internal/re.js"(exports, module) { + init_cjs_shim(); + var { + MAX_SAFE_COMPONENT_LENGTH, + MAX_SAFE_BUILD_LENGTH, + MAX_LENGTH + } = require_constants(); + var debug5 = require_debug(); + exports = module.exports = {}; + var re = exports.re = []; + var safeRe = exports.safeRe = []; + var src = exports.src = []; + var t = exports.t = {}; + var R = 0; + var LETTERDASHNUMBER = "[a-zA-Z0-9-]"; + var safeRegexReplacements = [ + ["\\s", 1], + ["\\d", MAX_LENGTH], + [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH] + ]; + var makeSafeRegex = (value) => { + for (const [token, max] of safeRegexReplacements) { + value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`); + } + return value; + }; + var createToken = (name, value, isGlobal) => { + const safe = makeSafeRegex(value); + const index = R++; + debug5(name, index, value); + t[name] = index; + src[index] = value; + re[index] = new RegExp(value, isGlobal ? "g" : void 0); + safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0); + }; + createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*"); + createToken("NUMERICIDENTIFIERLOOSE", "\\d+"); + createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`); + createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`); + createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`); + createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`); + createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`); + createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`); + createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`); + createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`); + createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`); + createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`); + createToken("FULL", `^${src[t.FULLPLAIN]}$`); + createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`); + createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`); + createToken("GTLT", "((?:<|>)?=?)"); + createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`); + createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`); + createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`); + createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`); + createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`); + createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`); + createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`); + createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`); + createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`); + createToken("COERCERTL", src[t.COERCE], true); + createToken("COERCERTLFULL", src[t.COERCEFULL], true); + createToken("LONETILDE", "(?:~>?)"); + createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true); + exports.tildeTrimReplace = "$1~"; + createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`); + createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`); + createToken("LONECARET", "(?:\\^)"); + createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true); + exports.caretTrimReplace = "$1^"; + createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`); + createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`); + createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`); + createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`); + createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true); + exports.comparatorTrimReplace = "$1$2$3"; + createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`); + createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`); + createToken("STAR", "(<|>)?=?\\s*\\*"); + createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"); + createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$"); + } +}); + +// ../testeranto/node_modules/semver/internal/parse-options.js +var require_parse_options = __commonJS({ + "../testeranto/node_modules/semver/internal/parse-options.js"(exports, module) { + init_cjs_shim(); + var looseOption = Object.freeze({ loose: true }); + var emptyOpts = Object.freeze({}); + var parseOptions = (options) => { + if (!options) { + return emptyOpts; + } + if (typeof options !== "object") { + return looseOption; + } + return options; + }; + module.exports = parseOptions; + } +}); + +// ../testeranto/node_modules/semver/internal/identifiers.js +var require_identifiers = __commonJS({ + "../testeranto/node_modules/semver/internal/identifiers.js"(exports, module) { + init_cjs_shim(); + var numeric = /^[0-9]+$/; + var compareIdentifiers = (a, b) => { + const anum = numeric.test(a); + const bnum = numeric.test(b); + if (anum && bnum) { + a = +a; + b = +b; + } + return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1; + }; + var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a); + module.exports = { + compareIdentifiers, + rcompareIdentifiers + }; + } +}); + +// ../testeranto/node_modules/semver/classes/semver.js +var require_semver = __commonJS({ + "../testeranto/node_modules/semver/classes/semver.js"(exports, module) { + init_cjs_shim(); + var debug5 = require_debug(); + var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants(); + var { safeRe: re, t } = require_re(); + var parseOptions = require_parse_options(); + var { compareIdentifiers } = require_identifiers(); + var SemVer = class { + constructor(version2, options) { + options = parseOptions(options); + if (version2 instanceof SemVer) { + if (version2.loose === !!options.loose && version2.includePrerelease === !!options.includePrerelease) { + return version2; + } else { + version2 = version2.version; + } + } else if (typeof version2 !== "string") { + throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version2}".`); + } + if (version2.length > MAX_LENGTH) { + throw new TypeError( + `version is longer than ${MAX_LENGTH} characters` + ); + } + debug5("SemVer", version2, options); + this.options = options; + this.loose = !!options.loose; + this.includePrerelease = !!options.includePrerelease; + const m = version2.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]); + if (!m) { + throw new TypeError(`Invalid Version: ${version2}`); + } + this.raw = version2; + this.major = +m[1]; + this.minor = +m[2]; + this.patch = +m[3]; + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError("Invalid major version"); + } + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError("Invalid minor version"); + } + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError("Invalid patch version"); + } + if (!m[4]) { + this.prerelease = []; + } else { + this.prerelease = m[4].split(".").map((id) => { + if (/^[0-9]+$/.test(id)) { + const num = +id; + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num; + } + } + return id; + }); + } + this.build = m[5] ? m[5].split(".") : []; + this.format(); + } + format() { + this.version = `${this.major}.${this.minor}.${this.patch}`; + if (this.prerelease.length) { + this.version += `-${this.prerelease.join(".")}`; + } + return this.version; + } + toString() { + return this.version; + } + compare(other) { + debug5("SemVer.compare", this.version, this.options, other); + if (!(other instanceof SemVer)) { + if (typeof other === "string" && other === this.version) { + return 0; + } + other = new SemVer(other, this.options); + } + if (other.version === this.version) { + return 0; + } + return this.compareMain(other) || this.comparePre(other); + } + compareMain(other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options); + } + return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch); + } + comparePre(other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options); + } + if (this.prerelease.length && !other.prerelease.length) { + return -1; + } else if (!this.prerelease.length && other.prerelease.length) { + return 1; + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0; + } + let i = 0; + do { + const a = this.prerelease[i]; + const b = other.prerelease[i]; + debug5("prerelease compare", i, a, b); + if (a === void 0 && b === void 0) { + return 0; + } else if (b === void 0) { + return 1; + } else if (a === void 0) { + return -1; + } else if (a === b) { + continue; + } else { + return compareIdentifiers(a, b); + } + } while (++i); + } + compareBuild(other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options); + } + let i = 0; + do { + const a = this.build[i]; + const b = other.build[i]; + debug5("build compare", i, a, b); + if (a === void 0 && b === void 0) { + return 0; + } else if (b === void 0) { + return 1; + } else if (a === void 0) { + return -1; + } else if (a === b) { + continue; + } else { + return compareIdentifiers(a, b); + } + } while (++i); + } + // preminor will bump the version up to the next minor release, and immediately + // down to pre-release. premajor and prepatch work the same way. + inc(release, identifier, identifierBase) { + switch (release) { + case "premajor": + this.prerelease.length = 0; + this.patch = 0; + this.minor = 0; + this.major++; + this.inc("pre", identifier, identifierBase); + break; + case "preminor": + this.prerelease.length = 0; + this.patch = 0; + this.minor++; + this.inc("pre", identifier, identifierBase); + break; + case "prepatch": + this.prerelease.length = 0; + this.inc("patch", identifier, identifierBase); + this.inc("pre", identifier, identifierBase); + break; + case "prerelease": + if (this.prerelease.length === 0) { + this.inc("patch", identifier, identifierBase); + } + this.inc("pre", identifier, identifierBase); + break; + case "major": + if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) { + this.major++; + } + this.minor = 0; + this.patch = 0; + this.prerelease = []; + break; + case "minor": + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++; + } + this.patch = 0; + this.prerelease = []; + break; + case "patch": + if (this.prerelease.length === 0) { + this.patch++; + } + this.prerelease = []; + break; + case "pre": { + const base = Number(identifierBase) ? 1 : 0; + if (!identifier && identifierBase === false) { + throw new Error("invalid increment argument: identifier is empty"); + } + if (this.prerelease.length === 0) { + this.prerelease = [base]; + } else { + let i = this.prerelease.length; + while (--i >= 0) { + if (typeof this.prerelease[i] === "number") { + this.prerelease[i]++; + i = -2; + } + } + if (i === -1) { + if (identifier === this.prerelease.join(".") && identifierBase === false) { + throw new Error("invalid increment argument: identifier already exists"); + } + this.prerelease.push(base); + } + } + if (identifier) { + let prerelease = [identifier, base]; + if (identifierBase === false) { + prerelease = [identifier]; + } + if (compareIdentifiers(this.prerelease[0], identifier) === 0) { + if (isNaN(this.prerelease[1])) { + this.prerelease = prerelease; + } + } else { + this.prerelease = prerelease; + } + } + break; + } + default: + throw new Error(`invalid increment argument: ${release}`); + } + this.raw = this.format(); + if (this.build.length) { + this.raw += `+${this.build.join(".")}`; + } + return this; + } + }; + module.exports = SemVer; + } +}); + +// ../testeranto/node_modules/semver/functions/parse.js +var require_parse = __commonJS({ + "../testeranto/node_modules/semver/functions/parse.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var parse = (version2, options, throwErrors = false) => { + if (version2 instanceof SemVer) { + return version2; + } + try { + return new SemVer(version2, options); + } catch (er) { + if (!throwErrors) { + return null; + } + throw er; + } + }; + module.exports = parse; + } +}); + +// ../testeranto/node_modules/semver/functions/valid.js +var require_valid = __commonJS({ + "../testeranto/node_modules/semver/functions/valid.js"(exports, module) { + init_cjs_shim(); + var parse = require_parse(); + var valid = (version2, options) => { + const v = parse(version2, options); + return v ? v.version : null; + }; + module.exports = valid; + } +}); + +// ../testeranto/node_modules/semver/functions/clean.js +var require_clean = __commonJS({ + "../testeranto/node_modules/semver/functions/clean.js"(exports, module) { + init_cjs_shim(); + var parse = require_parse(); + var clean = (version2, options) => { + const s = parse(version2.trim().replace(/^[=v]+/, ""), options); + return s ? s.version : null; + }; + module.exports = clean; + } +}); + +// ../testeranto/node_modules/semver/functions/inc.js +var require_inc = __commonJS({ + "../testeranto/node_modules/semver/functions/inc.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var inc = (version2, release, options, identifier, identifierBase) => { + if (typeof options === "string") { + identifierBase = identifier; + identifier = options; + options = void 0; + } + try { + return new SemVer( + version2 instanceof SemVer ? version2.version : version2, + options + ).inc(release, identifier, identifierBase).version; + } catch (er) { + return null; + } + }; + module.exports = inc; + } +}); + +// ../testeranto/node_modules/semver/functions/diff.js +var require_diff = __commonJS({ + "../testeranto/node_modules/semver/functions/diff.js"(exports, module) { + init_cjs_shim(); + var parse = require_parse(); + var diff = (version1, version2) => { + const v1 = parse(version1, null, true); + const v2 = parse(version2, null, true); + const comparison = v1.compare(v2); + if (comparison === 0) { + return null; + } + const v1Higher = comparison > 0; + const highVersion = v1Higher ? v1 : v2; + const lowVersion = v1Higher ? v2 : v1; + const highHasPre = !!highVersion.prerelease.length; + const lowHasPre = !!lowVersion.prerelease.length; + if (lowHasPre && !highHasPre) { + if (!lowVersion.patch && !lowVersion.minor) { + return "major"; + } + if (highVersion.patch) { + return "patch"; + } + if (highVersion.minor) { + return "minor"; + } + return "major"; + } + const prefix = highHasPre ? "pre" : ""; + if (v1.major !== v2.major) { + return prefix + "major"; + } + if (v1.minor !== v2.minor) { + return prefix + "minor"; + } + if (v1.patch !== v2.patch) { + return prefix + "patch"; + } + return "prerelease"; + }; + module.exports = diff; + } +}); + +// ../testeranto/node_modules/semver/functions/major.js +var require_major = __commonJS({ + "../testeranto/node_modules/semver/functions/major.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var major = (a, loose) => new SemVer(a, loose).major; + module.exports = major; + } +}); + +// ../testeranto/node_modules/semver/functions/minor.js +var require_minor = __commonJS({ + "../testeranto/node_modules/semver/functions/minor.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var minor = (a, loose) => new SemVer(a, loose).minor; + module.exports = minor; + } +}); + +// ../testeranto/node_modules/semver/functions/patch.js +var require_patch = __commonJS({ + "../testeranto/node_modules/semver/functions/patch.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var patch = (a, loose) => new SemVer(a, loose).patch; + module.exports = patch; + } +}); + +// ../testeranto/node_modules/semver/functions/prerelease.js +var require_prerelease = __commonJS({ + "../testeranto/node_modules/semver/functions/prerelease.js"(exports, module) { + init_cjs_shim(); + var parse = require_parse(); + var prerelease = (version2, options) => { + const parsed = parse(version2, options); + return parsed && parsed.prerelease.length ? parsed.prerelease : null; + }; + module.exports = prerelease; + } +}); + +// ../testeranto/node_modules/semver/functions/compare.js +var require_compare = __commonJS({ + "../testeranto/node_modules/semver/functions/compare.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose)); + module.exports = compare; + } +}); + +// ../testeranto/node_modules/semver/functions/rcompare.js +var require_rcompare = __commonJS({ + "../testeranto/node_modules/semver/functions/rcompare.js"(exports, module) { + init_cjs_shim(); + var compare = require_compare(); + var rcompare = (a, b, loose) => compare(b, a, loose); + module.exports = rcompare; + } +}); + +// ../testeranto/node_modules/semver/functions/compare-loose.js +var require_compare_loose = __commonJS({ + "../testeranto/node_modules/semver/functions/compare-loose.js"(exports, module) { + init_cjs_shim(); + var compare = require_compare(); + var compareLoose = (a, b) => compare(a, b, true); + module.exports = compareLoose; + } +}); + +// ../testeranto/node_modules/semver/functions/compare-build.js +var require_compare_build = __commonJS({ + "../testeranto/node_modules/semver/functions/compare-build.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var compareBuild = (a, b, loose) => { + const versionA = new SemVer(a, loose); + const versionB = new SemVer(b, loose); + return versionA.compare(versionB) || versionA.compareBuild(versionB); + }; + module.exports = compareBuild; + } +}); + +// ../testeranto/node_modules/semver/functions/sort.js +var require_sort = __commonJS({ + "../testeranto/node_modules/semver/functions/sort.js"(exports, module) { + init_cjs_shim(); + var compareBuild = require_compare_build(); + var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose)); + module.exports = sort; + } +}); + +// ../testeranto/node_modules/semver/functions/rsort.js +var require_rsort = __commonJS({ + "../testeranto/node_modules/semver/functions/rsort.js"(exports, module) { + init_cjs_shim(); + var compareBuild = require_compare_build(); + var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose)); + module.exports = rsort; + } +}); + +// ../testeranto/node_modules/semver/functions/gt.js +var require_gt = __commonJS({ + "../testeranto/node_modules/semver/functions/gt.js"(exports, module) { + init_cjs_shim(); + var compare = require_compare(); + var gt = (a, b, loose) => compare(a, b, loose) > 0; + module.exports = gt; + } +}); + +// ../testeranto/node_modules/semver/functions/lt.js +var require_lt = __commonJS({ + "../testeranto/node_modules/semver/functions/lt.js"(exports, module) { + init_cjs_shim(); + var compare = require_compare(); + var lt = (a, b, loose) => compare(a, b, loose) < 0; + module.exports = lt; + } +}); + +// ../testeranto/node_modules/semver/functions/eq.js +var require_eq = __commonJS({ + "../testeranto/node_modules/semver/functions/eq.js"(exports, module) { + init_cjs_shim(); + var compare = require_compare(); + var eq = (a, b, loose) => compare(a, b, loose) === 0; + module.exports = eq; + } +}); + +// ../testeranto/node_modules/semver/functions/neq.js +var require_neq = __commonJS({ + "../testeranto/node_modules/semver/functions/neq.js"(exports, module) { + init_cjs_shim(); + var compare = require_compare(); + var neq = (a, b, loose) => compare(a, b, loose) !== 0; + module.exports = neq; + } +}); + +// ../testeranto/node_modules/semver/functions/gte.js +var require_gte = __commonJS({ + "../testeranto/node_modules/semver/functions/gte.js"(exports, module) { + init_cjs_shim(); + var compare = require_compare(); + var gte = (a, b, loose) => compare(a, b, loose) >= 0; + module.exports = gte; + } +}); + +// ../testeranto/node_modules/semver/functions/lte.js +var require_lte = __commonJS({ + "../testeranto/node_modules/semver/functions/lte.js"(exports, module) { + init_cjs_shim(); + var compare = require_compare(); + var lte = (a, b, loose) => compare(a, b, loose) <= 0; + module.exports = lte; + } +}); + +// ../testeranto/node_modules/semver/functions/cmp.js +var require_cmp = __commonJS({ + "../testeranto/node_modules/semver/functions/cmp.js"(exports, module) { + init_cjs_shim(); + var eq = require_eq(); + var neq = require_neq(); + var gt = require_gt(); + var gte = require_gte(); + var lt = require_lt(); + var lte = require_lte(); + var cmp = (a, op, b, loose) => { + switch (op) { + case "===": + if (typeof a === "object") { + a = a.version; + } + if (typeof b === "object") { + b = b.version; + } + return a === b; + case "!==": + if (typeof a === "object") { + a = a.version; + } + if (typeof b === "object") { + b = b.version; + } + return a !== b; + case "": + case "=": + case "==": + return eq(a, b, loose); + case "!=": + return neq(a, b, loose); + case ">": + return gt(a, b, loose); + case ">=": + return gte(a, b, loose); + case "<": + return lt(a, b, loose); + case "<=": + return lte(a, b, loose); + default: + throw new TypeError(`Invalid operator: ${op}`); + } + }; + module.exports = cmp; + } +}); + +// ../testeranto/node_modules/semver/functions/coerce.js +var require_coerce = __commonJS({ + "../testeranto/node_modules/semver/functions/coerce.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var parse = require_parse(); + var { safeRe: re, t } = require_re(); + var coerce = (version2, options) => { + if (version2 instanceof SemVer) { + return version2; + } + if (typeof version2 === "number") { + version2 = String(version2); + } + if (typeof version2 !== "string") { + return null; + } + options = options || {}; + let match = null; + if (!options.rtl) { + match = version2.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]); + } else { + const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]; + let next; + while ((next = coerceRtlRegex.exec(version2)) && (!match || match.index + match[0].length !== version2.length)) { + if (!match || next.index + next[0].length !== match.index + match[0].length) { + match = next; + } + coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length; + } + coerceRtlRegex.lastIndex = -1; + } + if (match === null) { + return null; + } + const major = match[2]; + const minor = match[3] || "0"; + const patch = match[4] || "0"; + const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : ""; + const build = options.includePrerelease && match[6] ? `+${match[6]}` : ""; + return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options); + }; + module.exports = coerce; + } +}); + +// ../testeranto/node_modules/semver/internal/lrucache.js +var require_lrucache = __commonJS({ + "../testeranto/node_modules/semver/internal/lrucache.js"(exports, module) { + init_cjs_shim(); + var LRUCache = class { + constructor() { + this.max = 1e3; + this.map = /* @__PURE__ */ new Map(); + } + get(key) { + const value = this.map.get(key); + if (value === void 0) { + return void 0; + } else { + this.map.delete(key); + this.map.set(key, value); + return value; + } + } + delete(key) { + return this.map.delete(key); + } + set(key, value) { + const deleted = this.delete(key); + if (!deleted && value !== void 0) { + if (this.map.size >= this.max) { + const firstKey = this.map.keys().next().value; + this.delete(firstKey); + } + this.map.set(key, value); + } + return this; + } + }; + module.exports = LRUCache; + } +}); + +// ../testeranto/node_modules/semver/classes/range.js +var require_range = __commonJS({ + "../testeranto/node_modules/semver/classes/range.js"(exports, module) { + init_cjs_shim(); + var SPACE_CHARACTERS = /\s+/g; + var Range = class { + constructor(range, options) { + options = parseOptions(options); + if (range instanceof Range) { + if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) { + return range; + } else { + return new Range(range.raw, options); + } + } + if (range instanceof Comparator) { + this.raw = range.value; + this.set = [[range]]; + this.formatted = void 0; + return this; + } + this.options = options; + this.loose = !!options.loose; + this.includePrerelease = !!options.includePrerelease; + this.raw = range.trim().replace(SPACE_CHARACTERS, " "); + this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length); + if (!this.set.length) { + throw new TypeError(`Invalid SemVer Range: ${this.raw}`); + } + if (this.set.length > 1) { + const first = this.set[0]; + this.set = this.set.filter((c) => !isNullSet(c[0])); + if (this.set.length === 0) { + this.set = [first]; + } else if (this.set.length > 1) { + for (const c of this.set) { + if (c.length === 1 && isAny(c[0])) { + this.set = [c]; + break; + } + } + } + } + this.formatted = void 0; + } + get range() { + if (this.formatted === void 0) { + this.formatted = ""; + for (let i = 0; i < this.set.length; i++) { + if (i > 0) { + this.formatted += "||"; + } + const comps = this.set[i]; + for (let k = 0; k < comps.length; k++) { + if (k > 0) { + this.formatted += " "; + } + this.formatted += comps[k].toString().trim(); + } + } + } + return this.formatted; + } + format() { + return this.range; + } + toString() { + return this.range; + } + parseRange(range) { + const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE); + const memoKey = memoOpts + ":" + range; + const cached = cache.get(memoKey); + if (cached) { + return cached; + } + const loose = this.options.loose; + const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]; + range = range.replace(hr, hyphenReplace(this.options.includePrerelease)); + debug5("hyphen replace", range); + range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace); + debug5("comparator trim", range); + range = range.replace(re[t.TILDETRIM], tildeTrimReplace); + debug5("tilde trim", range); + range = range.replace(re[t.CARETTRIM], caretTrimReplace); + debug5("caret trim", range); + let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options)); + if (loose) { + rangeList = rangeList.filter((comp) => { + debug5("loose invalid filter", comp, this.options); + return !!comp.match(re[t.COMPARATORLOOSE]); + }); + } + debug5("range list", rangeList); + const rangeMap = /* @__PURE__ */ new Map(); + const comparators = rangeList.map((comp) => new Comparator(comp, this.options)); + for (const comp of comparators) { + if (isNullSet(comp)) { + return [comp]; + } + rangeMap.set(comp.value, comp); + } + if (rangeMap.size > 1 && rangeMap.has("")) { + rangeMap.delete(""); + } + const result = [...rangeMap.values()]; + cache.set(memoKey, result); + return result; + } + intersects(range, options) { + if (!(range instanceof Range)) { + throw new TypeError("a Range is required"); + } + return this.set.some((thisComparators) => { + return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => { + return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => { + return rangeComparators.every((rangeComparator) => { + return thisComparator.intersects(rangeComparator, options); + }); + }); + }); + }); + } + // if ANY of the sets match ALL of its comparators, then pass + test(version2) { + if (!version2) { + return false; + } + if (typeof version2 === "string") { + try { + version2 = new SemVer(version2, this.options); + } catch (er) { + return false; + } + } + for (let i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version2, this.options)) { + return true; + } + } + return false; + } + }; + module.exports = Range; + var LRU = require_lrucache(); + var cache = new LRU(); + var parseOptions = require_parse_options(); + var Comparator = require_comparator(); + var debug5 = require_debug(); + var SemVer = require_semver(); + var { + safeRe: re, + t, + comparatorTrimReplace, + tildeTrimReplace, + caretTrimReplace + } = require_re(); + var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants(); + var isNullSet = (c) => c.value === "<0.0.0-0"; + var isAny = (c) => c.value === ""; + var isSatisfiable = (comparators, options) => { + let result = true; + const remainingComparators = comparators.slice(); + let testComparator = remainingComparators.pop(); + while (result && remainingComparators.length) { + result = remainingComparators.every((otherComparator) => { + return testComparator.intersects(otherComparator, options); + }); + testComparator = remainingComparators.pop(); + } + return result; + }; + var parseComparator = (comp, options) => { + debug5("comp", comp, options); + comp = replaceCarets(comp, options); + debug5("caret", comp); + comp = replaceTildes(comp, options); + debug5("tildes", comp); + comp = replaceXRanges(comp, options); + debug5("xrange", comp); + comp = replaceStars(comp, options); + debug5("stars", comp); + return comp; + }; + var isX = (id) => !id || id.toLowerCase() === "x" || id === "*"; + var replaceTildes = (comp, options) => { + return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" "); + }; + var replaceTilde = (comp, options) => { + const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]; + return comp.replace(r, (_, M, m, p, pr) => { + debug5("tilde", comp, _, M, m, p, pr); + let ret; + if (isX(M)) { + ret = ""; + } else if (isX(m)) { + ret = `>=${M}.0.0 <${+M + 1}.0.0-0`; + } else if (isX(p)) { + ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`; + } else if (pr) { + debug5("replaceTilde pr", pr); + ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`; + } else { + ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`; + } + debug5("tilde return", ret); + return ret; + }); + }; + var replaceCarets = (comp, options) => { + return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" "); + }; + var replaceCaret = (comp, options) => { + debug5("caret", comp, options); + const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]; + const z = options.includePrerelease ? "-0" : ""; + return comp.replace(r, (_, M, m, p, pr) => { + debug5("caret", comp, _, M, m, p, pr); + let ret; + if (isX(M)) { + ret = ""; + } else if (isX(m)) { + ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`; + } else if (isX(p)) { + if (M === "0") { + ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`; + } else { + ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`; + } + } else if (pr) { + debug5("replaceCaret pr", pr); + if (M === "0") { + if (m === "0") { + ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`; + } else { + ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`; + } + } else { + ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`; + } + } else { + debug5("no pr"); + if (M === "0") { + if (m === "0") { + ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`; + } else { + ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`; + } + } else { + ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`; + } + } + debug5("caret return", ret); + return ret; + }); + }; + var replaceXRanges = (comp, options) => { + debug5("replaceXRanges", comp, options); + return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" "); + }; + var replaceXRange = (comp, options) => { + comp = comp.trim(); + const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]; + return comp.replace(r, (ret, gtlt, M, m, p, pr) => { + debug5("xRange", comp, ret, gtlt, M, m, p, pr); + const xM = isX(M); + const xm = xM || isX(m); + const xp = xm || isX(p); + const anyX = xp; + if (gtlt === "=" && anyX) { + gtlt = ""; + } + pr = options.includePrerelease ? "-0" : ""; + if (xM) { + if (gtlt === ">" || gtlt === "<") { + ret = "<0.0.0-0"; + } else { + ret = "*"; + } + } else if (gtlt && anyX) { + if (xm) { + m = 0; + } + p = 0; + if (gtlt === ">") { + gtlt = ">="; + if (xm) { + M = +M + 1; + m = 0; + p = 0; + } else { + m = +m + 1; + p = 0; + } + } else if (gtlt === "<=") { + gtlt = "<"; + if (xm) { + M = +M + 1; + } else { + m = +m + 1; + } + } + if (gtlt === "<") { + pr = "-0"; + } + ret = `${gtlt + M}.${m}.${p}${pr}`; + } else if (xm) { + ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`; + } else if (xp) { + ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`; + } + debug5("xRange return", ret); + return ret; + }); + }; + var replaceStars = (comp, options) => { + debug5("replaceStars", comp, options); + return comp.trim().replace(re[t.STAR], ""); + }; + var replaceGTE0 = (comp, options) => { + debug5("replaceGTE0", comp, options); + return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], ""); + }; + var hyphenReplace = (incPr) => ($0, from2, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => { + if (isX(fM)) { + from2 = ""; + } else if (isX(fm)) { + from2 = `>=${fM}.0.0${incPr ? "-0" : ""}`; + } else if (isX(fp)) { + from2 = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`; + } else if (fpr) { + from2 = `>=${from2}`; + } else { + from2 = `>=${from2}${incPr ? "-0" : ""}`; + } + if (isX(tM)) { + to = ""; + } else if (isX(tm)) { + to = `<${+tM + 1}.0.0-0`; + } else if (isX(tp)) { + to = `<${tM}.${+tm + 1}.0-0`; + } else if (tpr) { + to = `<=${tM}.${tm}.${tp}-${tpr}`; + } else if (incPr) { + to = `<${tM}.${tm}.${+tp + 1}-0`; + } else { + to = `<=${to}`; + } + return `${from2} ${to}`.trim(); + }; + var testSet = (set, version2, options) => { + for (let i = 0; i < set.length; i++) { + if (!set[i].test(version2)) { + return false; + } + } + if (version2.prerelease.length && !options.includePrerelease) { + for (let i = 0; i < set.length; i++) { + debug5(set[i].semver); + if (set[i].semver === Comparator.ANY) { + continue; + } + if (set[i].semver.prerelease.length > 0) { + const allowed = set[i].semver; + if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) { + return true; + } + } + } + return false; + } + return true; + }; + } +}); + +// ../testeranto/node_modules/semver/classes/comparator.js +var require_comparator = __commonJS({ + "../testeranto/node_modules/semver/classes/comparator.js"(exports, module) { + init_cjs_shim(); + var ANY = Symbol("SemVer ANY"); + var Comparator = class { + static get ANY() { + return ANY; + } + constructor(comp, options) { + options = parseOptions(options); + if (comp instanceof Comparator) { + if (comp.loose === !!options.loose) { + return comp; + } else { + comp = comp.value; + } + } + comp = comp.trim().split(/\s+/).join(" "); + debug5("comparator", comp, options); + this.options = options; + this.loose = !!options.loose; + this.parse(comp); + if (this.semver === ANY) { + this.value = ""; + } else { + this.value = this.operator + this.semver.version; + } + debug5("comp", this); + } + parse(comp) { + const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]; + const m = comp.match(r); + if (!m) { + throw new TypeError(`Invalid comparator: ${comp}`); + } + this.operator = m[1] !== void 0 ? m[1] : ""; + if (this.operator === "=") { + this.operator = ""; + } + if (!m[2]) { + this.semver = ANY; + } else { + this.semver = new SemVer(m[2], this.options.loose); + } + } + toString() { + return this.value; + } + test(version2) { + debug5("Comparator.test", version2, this.options.loose); + if (this.semver === ANY || version2 === ANY) { + return true; + } + if (typeof version2 === "string") { + try { + version2 = new SemVer(version2, this.options); + } catch (er) { + return false; + } + } + return cmp(version2, this.operator, this.semver, this.options); + } + intersects(comp, options) { + if (!(comp instanceof Comparator)) { + throw new TypeError("a Comparator is required"); + } + if (this.operator === "") { + if (this.value === "") { + return true; + } + return new Range(comp.value, options).test(this.value); + } else if (comp.operator === "") { + if (comp.value === "") { + return true; + } + return new Range(this.value, options).test(comp.semver); + } + options = parseOptions(options); + if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) { + return false; + } + if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) { + return false; + } + if (this.operator.startsWith(">") && comp.operator.startsWith(">")) { + return true; + } + if (this.operator.startsWith("<") && comp.operator.startsWith("<")) { + return true; + } + if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) { + return true; + } + if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) { + return true; + } + if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) { + return true; + } + return false; + } + }; + module.exports = Comparator; + var parseOptions = require_parse_options(); + var { safeRe: re, t } = require_re(); + var cmp = require_cmp(); + var debug5 = require_debug(); + var SemVer = require_semver(); + var Range = require_range(); + } +}); + +// ../testeranto/node_modules/semver/functions/satisfies.js +var require_satisfies = __commonJS({ + "../testeranto/node_modules/semver/functions/satisfies.js"(exports, module) { + init_cjs_shim(); + var Range = require_range(); + var satisfies = (version2, range, options) => { + try { + range = new Range(range, options); + } catch (er) { + return false; + } + return range.test(version2); + }; + module.exports = satisfies; + } +}); + +// ../testeranto/node_modules/semver/ranges/to-comparators.js +var require_to_comparators = __commonJS({ + "../testeranto/node_modules/semver/ranges/to-comparators.js"(exports, module) { + init_cjs_shim(); + var Range = require_range(); + var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" ")); + module.exports = toComparators; + } +}); + +// ../testeranto/node_modules/semver/ranges/max-satisfying.js +var require_max_satisfying = __commonJS({ + "../testeranto/node_modules/semver/ranges/max-satisfying.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var Range = require_range(); + var maxSatisfying = (versions, range, options) => { + let max = null; + let maxSV = null; + let rangeObj = null; + try { + rangeObj = new Range(range, options); + } catch (er) { + return null; + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + if (!max || maxSV.compare(v) === -1) { + max = v; + maxSV = new SemVer(max, options); + } + } + }); + return max; + }; + module.exports = maxSatisfying; + } +}); + +// ../testeranto/node_modules/semver/ranges/min-satisfying.js +var require_min_satisfying = __commonJS({ + "../testeranto/node_modules/semver/ranges/min-satisfying.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var Range = require_range(); + var minSatisfying = (versions, range, options) => { + let min = null; + let minSV = null; + let rangeObj = null; + try { + rangeObj = new Range(range, options); + } catch (er) { + return null; + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + if (!min || minSV.compare(v) === 1) { + min = v; + minSV = new SemVer(min, options); + } + } + }); + return min; + }; + module.exports = minSatisfying; + } +}); + +// ../testeranto/node_modules/semver/ranges/min-version.js +var require_min_version = __commonJS({ + "../testeranto/node_modules/semver/ranges/min-version.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var Range = require_range(); + var gt = require_gt(); + var minVersion = (range, loose) => { + range = new Range(range, loose); + let minver = new SemVer("0.0.0"); + if (range.test(minver)) { + return minver; + } + minver = new SemVer("0.0.0-0"); + if (range.test(minver)) { + return minver; + } + minver = null; + for (let i = 0; i < range.set.length; ++i) { + const comparators = range.set[i]; + let setMin = null; + comparators.forEach((comparator) => { + const compver = new SemVer(comparator.semver.version); + switch (comparator.operator) { + case ">": + if (compver.prerelease.length === 0) { + compver.patch++; + } else { + compver.prerelease.push(0); + } + compver.raw = compver.format(); + case "": + case ">=": + if (!setMin || gt(compver, setMin)) { + setMin = compver; + } + break; + case "<": + case "<=": + break; + default: + throw new Error(`Unexpected operation: ${comparator.operator}`); + } + }); + if (setMin && (!minver || gt(minver, setMin))) { + minver = setMin; + } + } + if (minver && range.test(minver)) { + return minver; + } + return null; + }; + module.exports = minVersion; + } +}); + +// ../testeranto/node_modules/semver/ranges/valid.js +var require_valid2 = __commonJS({ + "../testeranto/node_modules/semver/ranges/valid.js"(exports, module) { + init_cjs_shim(); + var Range = require_range(); + var validRange = (range, options) => { + try { + return new Range(range, options).range || "*"; + } catch (er) { + return null; + } + }; + module.exports = validRange; + } +}); + +// ../testeranto/node_modules/semver/ranges/outside.js +var require_outside = __commonJS({ + "../testeranto/node_modules/semver/ranges/outside.js"(exports, module) { + init_cjs_shim(); + var SemVer = require_semver(); + var Comparator = require_comparator(); + var { ANY } = Comparator; + var Range = require_range(); + var satisfies = require_satisfies(); + var gt = require_gt(); + var lt = require_lt(); + var lte = require_lte(); + var gte = require_gte(); + var outside = (version2, range, hilo, options) => { + version2 = new SemVer(version2, options); + range = new Range(range, options); + let gtfn, ltefn, ltfn, comp, ecomp; + switch (hilo) { + case ">": + gtfn = gt; + ltefn = lte; + ltfn = lt; + comp = ">"; + ecomp = ">="; + break; + case "<": + gtfn = lt; + ltefn = gte; + ltfn = gt; + comp = "<"; + ecomp = "<="; + break; + default: + throw new TypeError('Must provide a hilo val of "<" or ">"'); + } + if (satisfies(version2, range, options)) { + return false; + } + for (let i = 0; i < range.set.length; ++i) { + const comparators = range.set[i]; + let high = null; + let low = null; + comparators.forEach((comparator) => { + if (comparator.semver === ANY) { + comparator = new Comparator(">=0.0.0"); + } + high = high || comparator; + low = low || comparator; + if (gtfn(comparator.semver, high.semver, options)) { + high = comparator; + } else if (ltfn(comparator.semver, low.semver, options)) { + low = comparator; + } + }); + if (high.operator === comp || high.operator === ecomp) { + return false; + } + if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver)) { + return false; + } else if (low.operator === ecomp && ltfn(version2, low.semver)) { + return false; + } + } + return true; + }; + module.exports = outside; + } +}); + +// ../testeranto/node_modules/semver/ranges/gtr.js +var require_gtr = __commonJS({ + "../testeranto/node_modules/semver/ranges/gtr.js"(exports, module) { + init_cjs_shim(); + var outside = require_outside(); + var gtr = (version2, range, options) => outside(version2, range, ">", options); + module.exports = gtr; + } +}); + +// ../testeranto/node_modules/semver/ranges/ltr.js +var require_ltr = __commonJS({ + "../testeranto/node_modules/semver/ranges/ltr.js"(exports, module) { + init_cjs_shim(); + var outside = require_outside(); + var ltr = (version2, range, options) => outside(version2, range, "<", options); + module.exports = ltr; + } +}); + +// ../testeranto/node_modules/semver/ranges/intersects.js +var require_intersects = __commonJS({ + "../testeranto/node_modules/semver/ranges/intersects.js"(exports, module) { + init_cjs_shim(); + var Range = require_range(); + var intersects = (r1, r2, options) => { + r1 = new Range(r1, options); + r2 = new Range(r2, options); + return r1.intersects(r2, options); + }; + module.exports = intersects; + } +}); + +// ../testeranto/node_modules/semver/ranges/simplify.js +var require_simplify = __commonJS({ + "../testeranto/node_modules/semver/ranges/simplify.js"(exports, module) { + init_cjs_shim(); + var satisfies = require_satisfies(); + var compare = require_compare(); + module.exports = (versions, range, options) => { + const set = []; + let first = null; + let prev = null; + const v = versions.sort((a, b) => compare(a, b, options)); + for (const version2 of v) { + const included = satisfies(version2, range, options); + if (included) { + prev = version2; + if (!first) { + first = version2; + } + } else { + if (prev) { + set.push([first, prev]); + } + prev = null; + first = null; + } + } + if (first) { + set.push([first, null]); + } + const ranges = []; + for (const [min, max] of set) { + if (min === max) { + ranges.push(min); + } else if (!max && min === v[0]) { + ranges.push("*"); + } else if (!max) { + ranges.push(`>=${min}`); + } else if (min === v[0]) { + ranges.push(`<=${max}`); + } else { + ranges.push(`${min} - ${max}`); + } + } + const simplified = ranges.join(" || "); + const original = typeof range.raw === "string" ? range.raw : String(range); + return simplified.length < original.length ? simplified : range; + }; + } +}); + +// ../testeranto/node_modules/semver/ranges/subset.js +var require_subset = __commonJS({ + "../testeranto/node_modules/semver/ranges/subset.js"(exports, module) { + init_cjs_shim(); + var Range = require_range(); + var Comparator = require_comparator(); + var { ANY } = Comparator; + var satisfies = require_satisfies(); + var compare = require_compare(); + var subset = (sub, dom, options = {}) => { + if (sub === dom) { + return true; + } + sub = new Range(sub, options); + dom = new Range(dom, options); + let sawNonNull = false; + OUTER: + for (const simpleSub of sub.set) { + for (const simpleDom of dom.set) { + const isSub = simpleSubset(simpleSub, simpleDom, options); + sawNonNull = sawNonNull || isSub !== null; + if (isSub) { + continue OUTER; + } + } + if (sawNonNull) { + return false; + } + } + return true; + }; + var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")]; + var minimumVersion = [new Comparator(">=0.0.0")]; + var simpleSubset = (sub, dom, options) => { + if (sub === dom) { + return true; + } + if (sub.length === 1 && sub[0].semver === ANY) { + if (dom.length === 1 && dom[0].semver === ANY) { + return true; + } else if (options.includePrerelease) { + sub = minimumVersionWithPreRelease; + } else { + sub = minimumVersion; + } + } + if (dom.length === 1 && dom[0].semver === ANY) { + if (options.includePrerelease) { + return true; + } else { + dom = minimumVersion; + } + } + const eqSet = /* @__PURE__ */ new Set(); + let gt, lt; + for (const c of sub) { + if (c.operator === ">" || c.operator === ">=") { + gt = higherGT(gt, c, options); + } else if (c.operator === "<" || c.operator === "<=") { + lt = lowerLT(lt, c, options); + } else { + eqSet.add(c.semver); + } + } + if (eqSet.size > 1) { + return null; + } + let gtltComp; + if (gt && lt) { + gtltComp = compare(gt.semver, lt.semver, options); + if (gtltComp > 0) { + return null; + } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) { + return null; + } + } + for (const eq of eqSet) { + if (gt && !satisfies(eq, String(gt), options)) { + return null; + } + if (lt && !satisfies(eq, String(lt), options)) { + return null; + } + for (const c of dom) { + if (!satisfies(eq, String(c), options)) { + return false; + } + } + return true; + } + let higher, lower; + let hasDomLT, hasDomGT; + let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false; + let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false; + if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) { + needDomLTPre = false; + } + for (const c of dom) { + hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">="; + hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<="; + if (gt) { + if (needDomGTPre) { + if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) { + needDomGTPre = false; + } + } + if (c.operator === ">" || c.operator === ">=") { + higher = higherGT(gt, c, options); + if (higher === c && higher !== gt) { + return false; + } + } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) { + return false; + } + } + if (lt) { + if (needDomLTPre) { + if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) { + needDomLTPre = false; + } + } + if (c.operator === "<" || c.operator === "<=") { + lower = lowerLT(lt, c, options); + if (lower === c && lower !== lt) { + return false; + } + } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) { + return false; + } + } + if (!c.operator && (lt || gt) && gtltComp !== 0) { + return false; + } + } + if (gt && hasDomLT && !lt && gtltComp !== 0) { + return false; + } + if (lt && hasDomGT && !gt && gtltComp !== 0) { + return false; + } + if (needDomGTPre || needDomLTPre) { + return false; + } + return true; + }; + var higherGT = (a, b, options) => { + if (!a) { + return b; + } + const comp = compare(a.semver, b.semver, options); + return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a; + }; + var lowerLT = (a, b, options) => { + if (!a) { + return b; + } + const comp = compare(a.semver, b.semver, options); + return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a; + }; + module.exports = subset; + } +}); + +// ../testeranto/node_modules/semver/index.js +var require_semver2 = __commonJS({ + "../testeranto/node_modules/semver/index.js"(exports, module) { + init_cjs_shim(); + var internalRe = require_re(); + var constants = require_constants(); + var SemVer = require_semver(); + var identifiers = require_identifiers(); + var parse = require_parse(); + var valid = require_valid(); + var clean = require_clean(); + var inc = require_inc(); + var diff = require_diff(); + var major = require_major(); + var minor = require_minor(); + var patch = require_patch(); + var prerelease = require_prerelease(); + var compare = require_compare(); + var rcompare = require_rcompare(); + var compareLoose = require_compare_loose(); + var compareBuild = require_compare_build(); + var sort = require_sort(); + var rsort = require_rsort(); + var gt = require_gt(); + var lt = require_lt(); + var eq = require_eq(); + var neq = require_neq(); + var gte = require_gte(); + var lte = require_lte(); + var cmp = require_cmp(); + var coerce = require_coerce(); + var Comparator = require_comparator(); + var Range = require_range(); + var satisfies = require_satisfies(); + var toComparators = require_to_comparators(); + var maxSatisfying = require_max_satisfying(); + var minSatisfying = require_min_satisfying(); + var minVersion = require_min_version(); + var validRange = require_valid2(); + var outside = require_outside(); + var gtr = require_gtr(); + var ltr = require_ltr(); + var intersects = require_intersects(); + var simplifyRange = require_simplify(); + var subset = require_subset(); + module.exports = { + parse, + valid, + clean, + inc, + diff, + major, + minor, + patch, + prerelease, + compare, + rcompare, + compareLoose, + compareBuild, + sort, + rsort, + gt, + lt, + eq, + neq, + gte, + lte, + cmp, + coerce, + Comparator, + Range, + satisfies, + toComparators, + maxSatisfying, + minSatisfying, + minVersion, + validRange, + outside, + gtr, + ltr, + intersects, + simplifyRange, + subset, + SemVer, + re: internalRe.re, + src: internalRe.src, + tokens: internalRe.t, + SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION, + RELEASE_TYPES: constants.RELEASE_TYPES, + compareIdentifiers: identifiers.compareIdentifiers, + rcompareIdentifiers: identifiers.rcompareIdentifiers + }; + } +}); + +// ../testeranto/node_modules/proxy-agent/node_modules/lru-cache/index.js +var require_lru_cache = __commonJS({ + "../testeranto/node_modules/proxy-agent/node_modules/lru-cache/index.js"(exports, module) { + init_cjs_shim(); + var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date; + var hasAbortController = typeof AbortController === "function"; + var AC = hasAbortController ? AbortController : class AbortController { + constructor() { + this.signal = new AS(); + } + abort(reason = new Error("This operation was aborted")) { + this.signal.reason = this.signal.reason || reason; + this.signal.aborted = true; + this.signal.dispatchEvent({ + type: "abort", + target: this.signal + }); + } + }; + var hasAbortSignal = typeof AbortSignal === "function"; + var hasACAbortSignal = typeof AC.AbortSignal === "function"; + var AS = hasAbortSignal ? AbortSignal : hasACAbortSignal ? AC.AbortController : class AbortSignal { + constructor() { + this.reason = void 0; + this.aborted = false; + this._listeners = []; + } + dispatchEvent(e) { + if (e.type === "abort") { + this.aborted = true; + this.onabort(e); + this._listeners.forEach((f) => f(e), this); + } + } + onabort() { + } + addEventListener(ev, fn) { + if (ev === "abort") { + this._listeners.push(fn); + } + } + removeEventListener(ev, fn) { + if (ev === "abort") { + this._listeners = this._listeners.filter((f) => f !== fn); + } + } + }; + var warned = /* @__PURE__ */ new Set(); + var deprecatedOption = (opt, instead) => { + const code = `LRU_CACHE_OPTION_${opt}`; + if (shouldWarn(code)) { + warn(code, `${opt} option`, `options.${instead}`, LRUCache); + } + }; + var deprecatedMethod = (method, instead) => { + const code = `LRU_CACHE_METHOD_${method}`; + if (shouldWarn(code)) { + const { prototype } = LRUCache; + const { get } = Object.getOwnPropertyDescriptor(prototype, method); + warn(code, `${method} method`, `cache.${instead}()`, get); + } + }; + var deprecatedProperty = (field, instead) => { + const code = `LRU_CACHE_PROPERTY_${field}`; + if (shouldWarn(code)) { + const { prototype } = LRUCache; + const { get } = Object.getOwnPropertyDescriptor(prototype, field); + warn(code, `${field} property`, `cache.${instead}`, get); + } + }; + var emitWarning = (...a) => { + typeof process === "object" && process && typeof process.emitWarning === "function" ? process.emitWarning(...a) : console.error(...a); + }; + var shouldWarn = (code) => !warned.has(code); + var warn = (code, what, instead, fn) => { + warned.add(code); + const msg = `The ${what} is deprecated. Please use ${instead} instead.`; + emitWarning(msg, "DeprecationWarning", code, fn); + }; + var isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n); + var getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null; + var ZeroArray = class extends Array { + constructor(size) { + super(size); + this.fill(0); + } + }; + var Stack = class { + constructor(max) { + if (max === 0) { + return []; + } + const UintArray = getUintArray(max); + this.heap = new UintArray(max); + this.length = 0; + } + push(n) { + this.heap[this.length++] = n; + } + pop() { + return this.heap[--this.length]; + } + }; + var LRUCache = class { + constructor(options = {}) { + const { + max = 0, + ttl, + ttlResolution = 1, + ttlAutopurge, + updateAgeOnGet, + updateAgeOnHas, + allowStale, + dispose, + disposeAfter, + noDisposeOnSet, + noUpdateTTL, + maxSize = 0, + maxEntrySize = 0, + sizeCalculation, + fetchMethod, + fetchContext, + noDeleteOnFetchRejection, + noDeleteOnStaleGet, + allowStaleOnFetchRejection, + allowStaleOnFetchAbort, + ignoreFetchAbort + } = options; + const { length, maxAge, stale } = options instanceof LRUCache ? {} : options; + if (max !== 0 && !isPosInt(max)) { + throw new TypeError("max option must be a nonnegative integer"); + } + const UintArray = max ? getUintArray(max) : Array; + if (!UintArray) { + throw new Error("invalid max value: " + max); + } + this.max = max; + this.maxSize = maxSize; + this.maxEntrySize = maxEntrySize || this.maxSize; + this.sizeCalculation = sizeCalculation || length; + if (this.sizeCalculation) { + if (!this.maxSize && !this.maxEntrySize) { + throw new TypeError( + "cannot set sizeCalculation without setting maxSize or maxEntrySize" + ); + } + if (typeof this.sizeCalculation !== "function") { + throw new TypeError("sizeCalculation set to non-function"); + } + } + this.fetchMethod = fetchMethod || null; + if (this.fetchMethod && typeof this.fetchMethod !== "function") { + throw new TypeError( + "fetchMethod must be a function if specified" + ); + } + this.fetchContext = fetchContext; + if (!this.fetchMethod && fetchContext !== void 0) { + throw new TypeError( + "cannot set fetchContext without fetchMethod" + ); + } + this.keyMap = /* @__PURE__ */ new Map(); + this.keyList = new Array(max).fill(null); + this.valList = new Array(max).fill(null); + this.next = new UintArray(max); + this.prev = new UintArray(max); + this.head = 0; + this.tail = 0; + this.free = new Stack(max); + this.initialFill = 1; + this.size = 0; + if (typeof dispose === "function") { + this.dispose = dispose; + } + if (typeof disposeAfter === "function") { + this.disposeAfter = disposeAfter; + this.disposed = []; + } else { + this.disposeAfter = null; + this.disposed = null; + } + this.noDisposeOnSet = !!noDisposeOnSet; + this.noUpdateTTL = !!noUpdateTTL; + this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection; + this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection; + this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort; + this.ignoreFetchAbort = !!ignoreFetchAbort; + if (this.maxEntrySize !== 0) { + if (this.maxSize !== 0) { + if (!isPosInt(this.maxSize)) { + throw new TypeError( + "maxSize must be a positive integer if specified" + ); + } + } + if (!isPosInt(this.maxEntrySize)) { + throw new TypeError( + "maxEntrySize must be a positive integer if specified" + ); + } + this.initializeSizeTracking(); + } + this.allowStale = !!allowStale || !!stale; + this.noDeleteOnStaleGet = !!noDeleteOnStaleGet; + this.updateAgeOnGet = !!updateAgeOnGet; + this.updateAgeOnHas = !!updateAgeOnHas; + this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1; + this.ttlAutopurge = !!ttlAutopurge; + this.ttl = ttl || maxAge || 0; + if (this.ttl) { + if (!isPosInt(this.ttl)) { + throw new TypeError( + "ttl must be a positive integer if specified" + ); + } + this.initializeTTLTracking(); + } + if (this.max === 0 && this.ttl === 0 && this.maxSize === 0) { + throw new TypeError( + "At least one of max, maxSize, or ttl is required" + ); + } + if (!this.ttlAutopurge && !this.max && !this.maxSize) { + const code = "LRU_CACHE_UNBOUNDED"; + if (shouldWarn(code)) { + warned.add(code); + const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption."; + emitWarning(msg, "UnboundedCacheWarning", code, LRUCache); + } + } + if (stale) { + deprecatedOption("stale", "allowStale"); + } + if (maxAge) { + deprecatedOption("maxAge", "ttl"); + } + if (length) { + deprecatedOption("length", "sizeCalculation"); + } + } + getRemainingTTL(key) { + return this.has(key, { updateAgeOnHas: false }) ? Infinity : 0; + } + initializeTTLTracking() { + this.ttls = new ZeroArray(this.max); + this.starts = new ZeroArray(this.max); + this.setItemTTL = (index, ttl, start = perf.now()) => { + this.starts[index] = ttl !== 0 ? start : 0; + this.ttls[index] = ttl; + if (ttl !== 0 && this.ttlAutopurge) { + const t = setTimeout(() => { + if (this.isStale(index)) { + this.delete(this.keyList[index]); + } + }, ttl + 1); + if (t.unref) { + t.unref(); + } + } + }; + this.updateItemAge = (index) => { + this.starts[index] = this.ttls[index] !== 0 ? perf.now() : 0; + }; + this.statusTTL = (status, index) => { + if (status) { + status.ttl = this.ttls[index]; + status.start = this.starts[index]; + status.now = cachedNow || getNow(); + status.remainingTTL = status.now + status.ttl - status.start; + } + }; + let cachedNow = 0; + const getNow = () => { + const n = perf.now(); + if (this.ttlResolution > 0) { + cachedNow = n; + const t = setTimeout( + () => cachedNow = 0, + this.ttlResolution + ); + if (t.unref) { + t.unref(); + } + } + return n; + }; + this.getRemainingTTL = (key) => { + const index = this.keyMap.get(key); + if (index === void 0) { + return 0; + } + return this.ttls[index] === 0 || this.starts[index] === 0 ? Infinity : this.starts[index] + this.ttls[index] - (cachedNow || getNow()); + }; + this.isStale = (index) => { + return this.ttls[index] !== 0 && this.starts[index] !== 0 && (cachedNow || getNow()) - this.starts[index] > this.ttls[index]; + }; + } + updateItemAge(_index) { + } + statusTTL(_status, _index) { + } + setItemTTL(_index, _ttl, _start) { + } + isStale(_index) { + return false; + } + initializeSizeTracking() { + this.calculatedSize = 0; + this.sizes = new ZeroArray(this.max); + this.removeItemSize = (index) => { + this.calculatedSize -= this.sizes[index]; + this.sizes[index] = 0; + }; + this.requireSize = (k, v, size, sizeCalculation) => { + if (this.isBackgroundFetch(v)) { + return 0; + } + if (!isPosInt(size)) { + if (sizeCalculation) { + if (typeof sizeCalculation !== "function") { + throw new TypeError("sizeCalculation must be a function"); + } + size = sizeCalculation(v, k); + if (!isPosInt(size)) { + throw new TypeError( + "sizeCalculation return invalid (expect positive integer)" + ); + } + } else { + throw new TypeError( + "invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set." + ); + } + } + return size; + }; + this.addItemSize = (index, size, status) => { + this.sizes[index] = size; + if (this.maxSize) { + const maxSize = this.maxSize - this.sizes[index]; + while (this.calculatedSize > maxSize) { + this.evict(true); + } + } + this.calculatedSize += this.sizes[index]; + if (status) { + status.entrySize = size; + status.totalCalculatedSize = this.calculatedSize; + } + }; + } + removeItemSize(_index) { + } + addItemSize(_index, _size) { + } + requireSize(_k, _v, size, sizeCalculation) { + if (size || sizeCalculation) { + throw new TypeError( + "cannot set size without setting maxSize or maxEntrySize on cache" + ); + } + } + *indexes({ allowStale = this.allowStale } = {}) { + if (this.size) { + for (let i = this.tail; true; ) { + if (!this.isValidIndex(i)) { + break; + } + if (allowStale || !this.isStale(i)) { + yield i; + } + if (i === this.head) { + break; + } else { + i = this.prev[i]; + } + } + } + } + *rindexes({ allowStale = this.allowStale } = {}) { + if (this.size) { + for (let i = this.head; true; ) { + if (!this.isValidIndex(i)) { + break; + } + if (allowStale || !this.isStale(i)) { + yield i; + } + if (i === this.tail) { + break; + } else { + i = this.next[i]; + } + } + } + } + isValidIndex(index) { + return index !== void 0 && this.keyMap.get(this.keyList[index]) === index; + } + *entries() { + for (const i of this.indexes()) { + if (this.valList[i] !== void 0 && this.keyList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) { + yield [this.keyList[i], this.valList[i]]; + } + } + } + *rentries() { + for (const i of this.rindexes()) { + if (this.valList[i] !== void 0 && this.keyList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) { + yield [this.keyList[i], this.valList[i]]; + } + } + } + *keys() { + for (const i of this.indexes()) { + if (this.keyList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) { + yield this.keyList[i]; + } + } + } + *rkeys() { + for (const i of this.rindexes()) { + if (this.keyList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) { + yield this.keyList[i]; + } + } + } + *values() { + for (const i of this.indexes()) { + if (this.valList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) { + yield this.valList[i]; + } + } + } + *rvalues() { + for (const i of this.rindexes()) { + if (this.valList[i] !== void 0 && !this.isBackgroundFetch(this.valList[i])) { + yield this.valList[i]; + } + } + } + [Symbol.iterator]() { + return this.entries(); + } + find(fn, getOptions) { + for (const i of this.indexes()) { + const v = this.valList[i]; + const value = this.isBackgroundFetch(v) ? v.__staleWhileFetching : v; + if (value === void 0) + continue; + if (fn(value, this.keyList[i], this)) { + return this.get(this.keyList[i], getOptions); + } + } + } + forEach(fn, thisp = this) { + for (const i of this.indexes()) { + const v = this.valList[i]; + const value = this.isBackgroundFetch(v) ? v.__staleWhileFetching : v; + if (value === void 0) + continue; + fn.call(thisp, value, this.keyList[i], this); + } + } + rforEach(fn, thisp = this) { + for (const i of this.rindexes()) { + const v = this.valList[i]; + const value = this.isBackgroundFetch(v) ? v.__staleWhileFetching : v; + if (value === void 0) + continue; + fn.call(thisp, value, this.keyList[i], this); + } + } + get prune() { + deprecatedMethod("prune", "purgeStale"); + return this.purgeStale; + } + purgeStale() { + let deleted = false; + for (const i of this.rindexes({ allowStale: true })) { + if (this.isStale(i)) { + this.delete(this.keyList[i]); + deleted = true; + } + } + return deleted; + } + dump() { + const arr = []; + for (const i of this.indexes({ allowStale: true })) { + const key = this.keyList[i]; + const v = this.valList[i]; + const value = this.isBackgroundFetch(v) ? v.__staleWhileFetching : v; + if (value === void 0) + continue; + const entry = { value }; + if (this.ttls) { + entry.ttl = this.ttls[i]; + const age = perf.now() - this.starts[i]; + entry.start = Math.floor(Date.now() - age); + } + if (this.sizes) { + entry.size = this.sizes[i]; + } + arr.unshift([key, entry]); + } + return arr; + } + load(arr) { + this.clear(); + for (const [key, entry] of arr) { + if (entry.start) { + const age = Date.now() - entry.start; + entry.start = perf.now() - age; + } + this.set(key, entry.value, entry); + } + } + dispose(_v, _k, _reason) { + } + set(k, v, { + ttl = this.ttl, + start, + noDisposeOnSet = this.noDisposeOnSet, + size = 0, + sizeCalculation = this.sizeCalculation, + noUpdateTTL = this.noUpdateTTL, + status + } = {}) { + size = this.requireSize(k, v, size, sizeCalculation); + if (this.maxEntrySize && size > this.maxEntrySize) { + if (status) { + status.set = "miss"; + status.maxEntrySizeExceeded = true; + } + this.delete(k); + return this; + } + let index = this.size === 0 ? void 0 : this.keyMap.get(k); + if (index === void 0) { + index = this.newIndex(); + this.keyList[index] = k; + this.valList[index] = v; + this.keyMap.set(k, index); + this.next[this.tail] = index; + this.prev[index] = this.tail; + this.tail = index; + this.size++; + this.addItemSize(index, size, status); + if (status) { + status.set = "add"; + } + noUpdateTTL = false; + } else { + this.moveToTail(index); + const oldVal = this.valList[index]; + if (v !== oldVal) { + if (this.isBackgroundFetch(oldVal)) { + oldVal.__abortController.abort(new Error("replaced")); + } else { + if (!noDisposeOnSet) { + this.dispose(oldVal, k, "set"); + if (this.disposeAfter) { + this.disposed.push([oldVal, k, "set"]); + } + } + } + this.removeItemSize(index); + this.valList[index] = v; + this.addItemSize(index, size, status); + if (status) { + status.set = "replace"; + const oldValue = oldVal && this.isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal; + if (oldValue !== void 0) + status.oldValue = oldValue; + } + } else if (status) { + status.set = "update"; + } + } + if (ttl !== 0 && this.ttl === 0 && !this.ttls) { + this.initializeTTLTracking(); + } + if (!noUpdateTTL) { + this.setItemTTL(index, ttl, start); + } + this.statusTTL(status, index); + if (this.disposeAfter) { + while (this.disposed.length) { + this.disposeAfter(...this.disposed.shift()); + } + } + return this; + } + newIndex() { + if (this.size === 0) { + return this.tail; + } + if (this.size === this.max && this.max !== 0) { + return this.evict(false); + } + if (this.free.length !== 0) { + return this.free.pop(); + } + return this.initialFill++; + } + pop() { + if (this.size) { + const val = this.valList[this.head]; + this.evict(true); + return val; + } + } + evict(free) { + const head = this.head; + const k = this.keyList[head]; + const v = this.valList[head]; + if (this.isBackgroundFetch(v)) { + v.__abortController.abort(new Error("evicted")); + } else { + this.dispose(v, k, "evict"); + if (this.disposeAfter) { + this.disposed.push([v, k, "evict"]); + } + } + this.removeItemSize(head); + if (free) { + this.keyList[head] = null; + this.valList[head] = null; + this.free.push(head); + } + this.head = this.next[head]; + this.keyMap.delete(k); + this.size--; + return head; + } + has(k, { updateAgeOnHas = this.updateAgeOnHas, status } = {}) { + const index = this.keyMap.get(k); + if (index !== void 0) { + if (!this.isStale(index)) { + if (updateAgeOnHas) { + this.updateItemAge(index); + } + if (status) + status.has = "hit"; + this.statusTTL(status, index); + return true; + } else if (status) { + status.has = "stale"; + this.statusTTL(status, index); + } + } else if (status) { + status.has = "miss"; + } + return false; + } + // like get(), but without any LRU updating or TTL expiration + peek(k, { allowStale = this.allowStale } = {}) { + const index = this.keyMap.get(k); + if (index !== void 0 && (allowStale || !this.isStale(index))) { + const v = this.valList[index]; + return this.isBackgroundFetch(v) ? v.__staleWhileFetching : v; + } + } + backgroundFetch(k, index, options, context) { + const v = index === void 0 ? void 0 : this.valList[index]; + if (this.isBackgroundFetch(v)) { + return v; + } + const ac = new AC(); + if (options.signal) { + options.signal.addEventListener( + "abort", + () => ac.abort(options.signal.reason) + ); + } + const fetchOpts = { + signal: ac.signal, + options, + context + }; + const cb = (v2, updateCache = false) => { + const { aborted } = ac.signal; + const ignoreAbort = options.ignoreFetchAbort && v2 !== void 0; + if (options.status) { + if (aborted && !updateCache) { + options.status.fetchAborted = true; + options.status.fetchError = ac.signal.reason; + if (ignoreAbort) + options.status.fetchAbortIgnored = true; + } else { + options.status.fetchResolved = true; + } + } + if (aborted && !ignoreAbort && !updateCache) { + return fetchFail(ac.signal.reason); + } + if (this.valList[index] === p) { + if (v2 === void 0) { + if (p.__staleWhileFetching) { + this.valList[index] = p.__staleWhileFetching; + } else { + this.delete(k); + } + } else { + if (options.status) + options.status.fetchUpdated = true; + this.set(k, v2, fetchOpts.options); + } + } + return v2; + }; + const eb = (er) => { + if (options.status) { + options.status.fetchRejected = true; + options.status.fetchError = er; + } + return fetchFail(er); + }; + const fetchFail = (er) => { + const { aborted } = ac.signal; + const allowStaleAborted = aborted && options.allowStaleOnFetchAbort; + const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection; + const noDelete = allowStale || options.noDeleteOnFetchRejection; + if (this.valList[index] === p) { + const del = !noDelete || p.__staleWhileFetching === void 0; + if (del) { + this.delete(k); + } else if (!allowStaleAborted) { + this.valList[index] = p.__staleWhileFetching; + } + } + if (allowStale) { + if (options.status && p.__staleWhileFetching !== void 0) { + options.status.returnedStale = true; + } + return p.__staleWhileFetching; + } else if (p.__returned === p) { + throw er; + } + }; + const pcall = (res, rej) => { + this.fetchMethod(k, v, fetchOpts).then((v2) => res(v2), rej); + ac.signal.addEventListener("abort", () => { + if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) { + res(); + if (options.allowStaleOnFetchAbort) { + res = (v2) => cb(v2, true); + } + } + }); + }; + if (options.status) + options.status.fetchDispatched = true; + const p = new Promise(pcall).then(cb, eb); + p.__abortController = ac; + p.__staleWhileFetching = v; + p.__returned = null; + if (index === void 0) { + this.set(k, p, { ...fetchOpts.options, status: void 0 }); + index = this.keyMap.get(k); + } else { + this.valList[index] = p; + } + return p; + } + isBackgroundFetch(p) { + return p && typeof p === "object" && typeof p.then === "function" && Object.prototype.hasOwnProperty.call( + p, + "__staleWhileFetching" + ) && Object.prototype.hasOwnProperty.call(p, "__returned") && (p.__returned === p || p.__returned === null); + } + // this takes the union of get() and set() opts, because it does both + async fetch(k, { + // get options + allowStale = this.allowStale, + updateAgeOnGet = this.updateAgeOnGet, + noDeleteOnStaleGet = this.noDeleteOnStaleGet, + // set options + ttl = this.ttl, + noDisposeOnSet = this.noDisposeOnSet, + size = 0, + sizeCalculation = this.sizeCalculation, + noUpdateTTL = this.noUpdateTTL, + // fetch exclusive options + noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, + allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, + ignoreFetchAbort = this.ignoreFetchAbort, + allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, + fetchContext = this.fetchContext, + forceRefresh = false, + status, + signal + } = {}) { + if (!this.fetchMethod) { + if (status) + status.fetch = "get"; + return this.get(k, { + allowStale, + updateAgeOnGet, + noDeleteOnStaleGet, + status + }); + } + const options = { + allowStale, + updateAgeOnGet, + noDeleteOnStaleGet, + ttl, + noDisposeOnSet, + size, + sizeCalculation, + noUpdateTTL, + noDeleteOnFetchRejection, + allowStaleOnFetchRejection, + allowStaleOnFetchAbort, + ignoreFetchAbort, + status, + signal + }; + let index = this.keyMap.get(k); + if (index === void 0) { + if (status) + status.fetch = "miss"; + const p = this.backgroundFetch(k, index, options, fetchContext); + return p.__returned = p; + } else { + const v = this.valList[index]; + if (this.isBackgroundFetch(v)) { + const stale = allowStale && v.__staleWhileFetching !== void 0; + if (status) { + status.fetch = "inflight"; + if (stale) + status.returnedStale = true; + } + return stale ? v.__staleWhileFetching : v.__returned = v; + } + const isStale = this.isStale(index); + if (!forceRefresh && !isStale) { + if (status) + status.fetch = "hit"; + this.moveToTail(index); + if (updateAgeOnGet) { + this.updateItemAge(index); + } + this.statusTTL(status, index); + return v; + } + const p = this.backgroundFetch(k, index, options, fetchContext); + const hasStale = p.__staleWhileFetching !== void 0; + const staleVal = hasStale && allowStale; + if (status) { + status.fetch = hasStale && isStale ? "stale" : "refresh"; + if (staleVal && isStale) + status.returnedStale = true; + } + return staleVal ? p.__staleWhileFetching : p.__returned = p; + } + } + get(k, { + allowStale = this.allowStale, + updateAgeOnGet = this.updateAgeOnGet, + noDeleteOnStaleGet = this.noDeleteOnStaleGet, + status + } = {}) { + const index = this.keyMap.get(k); + if (index !== void 0) { + const value = this.valList[index]; + const fetching = this.isBackgroundFetch(value); + this.statusTTL(status, index); + if (this.isStale(index)) { + if (status) + status.get = "stale"; + if (!fetching) { + if (!noDeleteOnStaleGet) { + this.delete(k); + } + if (status) + status.returnedStale = allowStale; + return allowStale ? value : void 0; + } else { + if (status) { + status.returnedStale = allowStale && value.__staleWhileFetching !== void 0; + } + return allowStale ? value.__staleWhileFetching : void 0; + } + } else { + if (status) + status.get = "hit"; + if (fetching) { + return value.__staleWhileFetching; + } + this.moveToTail(index); + if (updateAgeOnGet) { + this.updateItemAge(index); + } + return value; + } + } else if (status) { + status.get = "miss"; + } + } + connect(p, n) { + this.prev[n] = p; + this.next[p] = n; + } + moveToTail(index) { + if (index !== this.tail) { + if (index === this.head) { + this.head = this.next[index]; + } else { + this.connect(this.prev[index], this.next[index]); + } + this.connect(this.tail, index); + this.tail = index; + } + } + get del() { + deprecatedMethod("del", "delete"); + return this.delete; + } + delete(k) { + let deleted = false; + if (this.size !== 0) { + const index = this.keyMap.get(k); + if (index !== void 0) { + deleted = true; + if (this.size === 1) { + this.clear(); + } else { + this.removeItemSize(index); + const v = this.valList[index]; + if (this.isBackgroundFetch(v)) { + v.__abortController.abort(new Error("deleted")); + } else { + this.dispose(v, k, "delete"); + if (this.disposeAfter) { + this.disposed.push([v, k, "delete"]); + } + } + this.keyMap.delete(k); + this.keyList[index] = null; + this.valList[index] = null; + if (index === this.tail) { + this.tail = this.prev[index]; + } else if (index === this.head) { + this.head = this.next[index]; + } else { + this.next[this.prev[index]] = this.next[index]; + this.prev[this.next[index]] = this.prev[index]; + } + this.size--; + this.free.push(index); + } + } + } + if (this.disposed) { + while (this.disposed.length) { + this.disposeAfter(...this.disposed.shift()); + } + } + return deleted; + } + clear() { + for (const index of this.rindexes({ allowStale: true })) { + const v = this.valList[index]; + if (this.isBackgroundFetch(v)) { + v.__abortController.abort(new Error("deleted")); + } else { + const k = this.keyList[index]; + this.dispose(v, k, "delete"); + if (this.disposeAfter) { + this.disposed.push([v, k, "delete"]); + } + } + } + this.keyMap.clear(); + this.valList.fill(null); + this.keyList.fill(null); + if (this.ttls) { + this.ttls.fill(0); + this.starts.fill(0); + } + if (this.sizes) { + this.sizes.fill(0); + } + this.head = 0; + this.tail = 0; + this.initialFill = 1; + this.free.length = 0; + this.calculatedSize = 0; + this.size = 0; + if (this.disposed) { + while (this.disposed.length) { + this.disposeAfter(...this.disposed.shift()); + } + } + } + get reset() { + deprecatedMethod("reset", "clear"); + return this.clear; + } + get length() { + deprecatedProperty("length", "size"); + return this.size; + } + static get AbortController() { + return AC; + } + static get AbortSignal() { + return AS; + } + }; + module.exports = LRUCache; + } +}); + +// ../testeranto/node_modules/agent-base/dist/helpers.js +var require_helpers = __commonJS({ + "../testeranto/node_modules/agent-base/dist/helpers.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.req = exports.json = exports.toBuffer = void 0; + var http2 = __importStar2(__require("http")); + var https2 = __importStar2(__require("https")); + async function toBuffer(stream) { + let length = 0; + const chunks = []; + for await (const chunk of stream) { + length += chunk.length; + chunks.push(chunk); + } + return Buffer.concat(chunks, length); + } + exports.toBuffer = toBuffer; + async function json(stream) { + const buf = await toBuffer(stream); + const str = buf.toString("utf8"); + try { + return JSON.parse(str); + } catch (_err) { + const err = _err; + err.message += ` (input: ${str})`; + throw err; + } + } + exports.json = json; + function req(url, opts = {}) { + const href = typeof url === "string" ? url : url.href; + const req2 = (href.startsWith("https:") ? https2 : http2).request(url, opts); + const promise = new Promise((resolve5, reject) => { + req2.once("response", resolve5).once("error", reject).end(); + }); + req2.then = promise.then.bind(promise); + return req2; + } + exports.req = req; + } +}); + +// ../testeranto/node_modules/agent-base/dist/index.js +var require_dist = __commonJS({ + "../testeranto/node_modules/agent-base/dist/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + var __exportStar2 = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) + __createBinding2(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Agent = void 0; + var net = __importStar2(__require("net")); + var http2 = __importStar2(__require("http")); + var https_1 = __require("https"); + __exportStar2(require_helpers(), exports); + var INTERNAL = Symbol("AgentBaseInternalState"); + var Agent = class extends http2.Agent { + constructor(opts) { + super(opts); + this[INTERNAL] = {}; + } + /** + * Determine whether this is an `http` or `https` request. + */ + isSecureEndpoint(options) { + if (options) { + if (typeof options.secureEndpoint === "boolean") { + return options.secureEndpoint; + } + if (typeof options.protocol === "string") { + return options.protocol === "https:"; + } + } + const { stack } = new Error(); + if (typeof stack !== "string") + return false; + return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1); + } + // In order to support async signatures in `connect()` and Node's native + // connection pooling in `http.Agent`, the array of sockets for each origin + // has to be updated synchronously. This is so the length of the array is + // accurate when `addRequest()` is next called. We achieve this by creating a + // fake socket and adding it to `sockets[origin]` and incrementing + // `totalSocketCount`. + incrementSockets(name) { + if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) { + return null; + } + if (!this.sockets[name]) { + this.sockets[name] = []; + } + const fakeSocket = new net.Socket({ writable: false }); + this.sockets[name].push(fakeSocket); + this.totalSocketCount++; + return fakeSocket; + } + decrementSockets(name, socket) { + if (!this.sockets[name] || socket === null) { + return; + } + const sockets = this.sockets[name]; + const index = sockets.indexOf(socket); + if (index !== -1) { + sockets.splice(index, 1); + this.totalSocketCount--; + if (sockets.length === 0) { + delete this.sockets[name]; + } + } + } + // In order to properly update the socket pool, we need to call `getName()` on + // the core `https.Agent` if it is a secureEndpoint. + getName(options) { + const secureEndpoint = typeof options.secureEndpoint === "boolean" ? options.secureEndpoint : this.isSecureEndpoint(options); + if (secureEndpoint) { + return https_1.Agent.prototype.getName.call(this, options); + } + return super.getName(options); + } + createSocket(req, options, cb) { + const connectOpts = { + ...options, + secureEndpoint: this.isSecureEndpoint(options) + }; + const name = this.getName(connectOpts); + const fakeSocket = this.incrementSockets(name); + Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => { + this.decrementSockets(name, fakeSocket); + if (socket instanceof http2.Agent) { + return socket.addRequest(req, connectOpts); + } + this[INTERNAL].currentSocket = socket; + super.createSocket(req, options, cb); + }, (err) => { + this.decrementSockets(name, fakeSocket); + cb(err); + }); + } + createConnection() { + const socket = this[INTERNAL].currentSocket; + this[INTERNAL].currentSocket = void 0; + if (!socket) { + throw new Error("No socket was returned in the `connect()` function"); + } + return socket; + } + get defaultPort() { + return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80); + } + set defaultPort(v) { + if (this[INTERNAL]) { + this[INTERNAL].defaultPort = v; + } + } + get protocol() { + return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:"); + } + set protocol(v) { + if (this[INTERNAL]) { + this[INTERNAL].protocol = v; + } + } + }; + exports.Agent = Agent; + } +}); + +// ../testeranto/node_modules/proxy-from-env/index.js +var require_proxy_from_env = __commonJS({ + "../testeranto/node_modules/proxy-from-env/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var parseUrl = __require("url").parse; + var DEFAULT_PORTS = { + ftp: 21, + gopher: 70, + http: 80, + https: 443, + ws: 80, + wss: 443 + }; + var stringEndsWith = String.prototype.endsWith || function(s) { + return s.length <= this.length && this.indexOf(s, this.length - s.length) !== -1; + }; + function getProxyForUrl(url) { + var parsedUrl = typeof url === "string" ? parseUrl(url) : url || {}; + var proto = parsedUrl.protocol; + var hostname = parsedUrl.host; + var port = parsedUrl.port; + if (typeof hostname !== "string" || !hostname || typeof proto !== "string") { + return ""; + } + proto = proto.split(":", 1)[0]; + hostname = hostname.replace(/:\d*$/, ""); + port = parseInt(port) || DEFAULT_PORTS[proto] || 0; + if (!shouldProxy(hostname, port)) { + return ""; + } + var proxy = getEnv("npm_config_" + proto + "_proxy") || getEnv(proto + "_proxy") || getEnv("npm_config_proxy") || getEnv("all_proxy"); + if (proxy && proxy.indexOf("://") === -1) { + proxy = proto + "://" + proxy; + } + return proxy; + } + function shouldProxy(hostname, port) { + var NO_PROXY = (getEnv("npm_config_no_proxy") || getEnv("no_proxy")).toLowerCase(); + if (!NO_PROXY) { + return true; + } + if (NO_PROXY === "*") { + return false; + } + return NO_PROXY.split(/[,\s]/).every(function(proxy) { + if (!proxy) { + return true; + } + var parsedProxy = proxy.match(/^(.+):(\d+)$/); + var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy; + var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0; + if (parsedProxyPort && parsedProxyPort !== port) { + return true; + } + if (!/^[.*]/.test(parsedProxyHostname)) { + return hostname !== parsedProxyHostname; + } + if (parsedProxyHostname.charAt(0) === "*") { + parsedProxyHostname = parsedProxyHostname.slice(1); + } + return !stringEndsWith.call(hostname, parsedProxyHostname); + }); + } + function getEnv(key) { + return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || ""; + } + exports.getProxyForUrl = getProxyForUrl; + } +}); + +// ../testeranto/node_modules/http-proxy-agent/dist/index.js +var require_dist2 = __commonJS({ + "../testeranto/node_modules/http-proxy-agent/dist/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.HttpProxyAgent = void 0; + var net = __importStar2(__require("net")); + var tls = __importStar2(__require("tls")); + var debug_1 = __importDefault2(require_src()); + var events_1 = __require("events"); + var agent_base_1 = require_dist(); + var url_1 = __require("url"); + var debug5 = (0, debug_1.default)("http-proxy-agent"); + var HttpProxyAgent = class extends agent_base_1.Agent { + constructor(proxy, opts) { + super(opts); + this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy; + this.proxyHeaders = opts?.headers ?? {}; + debug5("Creating new HttpProxyAgent instance: %o", this.proxy.href); + const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, ""); + const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80; + this.connectOpts = { + ...opts ? omit(opts, "headers") : null, + host, + port + }; + } + addRequest(req, opts) { + req._header = null; + this.setRequestProps(req, opts); + super.addRequest(req, opts); + } + setRequestProps(req, opts) { + const { proxy } = this; + const protocol = opts.secureEndpoint ? "https:" : "http:"; + const hostname = req.getHeader("host") || "localhost"; + const base = `${protocol}//${hostname}`; + const url = new url_1.URL(req.path, base); + if (opts.port !== 80) { + url.port = String(opts.port); + } + req.path = String(url); + const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders }; + if (proxy.username || proxy.password) { + const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`; + headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`; + } + if (!headers["Proxy-Connection"]) { + headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close"; + } + for (const name of Object.keys(headers)) { + const value = headers[name]; + if (value) { + req.setHeader(name, value); + } + } + } + async connect(req, opts) { + req._header = null; + if (!req.path.includes("://")) { + this.setRequestProps(req, opts); + } + let first; + let endOfHeaders; + debug5("Regenerating stored HTTP header string for request"); + req._implicitHeader(); + if (req.outputData && req.outputData.length > 0) { + debug5("Patching connection write() output buffer with updated header"); + first = req.outputData[0].data; + endOfHeaders = first.indexOf("\r\n\r\n") + 4; + req.outputData[0].data = req._header + first.substring(endOfHeaders); + debug5("Output buffer: %o", req.outputData[0].data); + } + let socket; + if (this.proxy.protocol === "https:") { + debug5("Creating `tls.Socket`: %o", this.connectOpts); + socket = tls.connect(this.connectOpts); + } else { + debug5("Creating `net.Socket`: %o", this.connectOpts); + socket = net.connect(this.connectOpts); + } + await (0, events_1.once)(socket, "connect"); + return socket; + } + }; + HttpProxyAgent.protocols = ["http", "https"]; + exports.HttpProxyAgent = HttpProxyAgent; + function omit(obj, ...keys) { + const ret = {}; + let key; + for (key in obj) { + if (!keys.includes(key)) { + ret[key] = obj[key]; + } + } + return ret; + } + } +}); + +// ../testeranto/node_modules/https-proxy-agent/dist/parse-proxy-response.js +var require_parse_proxy_response = __commonJS({ + "../testeranto/node_modules/https-proxy-agent/dist/parse-proxy-response.js"(exports) { + "use strict"; + init_cjs_shim(); + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.parseProxyResponse = void 0; + var debug_1 = __importDefault2(require_src()); + var debug5 = (0, debug_1.default)("https-proxy-agent:parse-proxy-response"); + function parseProxyResponse(socket) { + return new Promise((resolve5, reject) => { + let buffersLength = 0; + const buffers = []; + function read() { + const b = socket.read(); + if (b) + ondata(b); + else + socket.once("readable", read); + } + function cleanup() { + socket.removeListener("end", onend); + socket.removeListener("error", onerror); + socket.removeListener("readable", read); + } + function onend() { + cleanup(); + debug5("onend"); + reject(new Error("Proxy connection ended before receiving CONNECT response")); + } + function onerror(err) { + cleanup(); + debug5("onerror %o", err); + reject(err); + } + function ondata(b) { + buffers.push(b); + buffersLength += b.length; + const buffered = Buffer.concat(buffers, buffersLength); + const endOfHeaders = buffered.indexOf("\r\n\r\n"); + if (endOfHeaders === -1) { + debug5("have not received end of HTTP headers yet..."); + read(); + return; + } + const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split("\r\n"); + const firstLine = headerParts.shift(); + if (!firstLine) { + socket.destroy(); + return reject(new Error("No header received from proxy CONNECT response")); + } + const firstLineParts = firstLine.split(" "); + const statusCode = +firstLineParts[1]; + const statusText = firstLineParts.slice(2).join(" "); + const headers = {}; + for (const header of headerParts) { + if (!header) + continue; + const firstColon = header.indexOf(":"); + if (firstColon === -1) { + socket.destroy(); + return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`)); + } + const key = header.slice(0, firstColon).toLowerCase(); + const value = header.slice(firstColon + 1).trimStart(); + const current = headers[key]; + if (typeof current === "string") { + headers[key] = [current, value]; + } else if (Array.isArray(current)) { + current.push(value); + } else { + headers[key] = value; + } + } + debug5("got proxy server response: %o %o", firstLine, headers); + cleanup(); + resolve5({ + connect: { + statusCode, + statusText, + headers + }, + buffered + }); + } + socket.on("error", onerror); + socket.on("end", onend); + read(); + }); + } + exports.parseProxyResponse = parseProxyResponse; + } +}); + +// ../testeranto/node_modules/https-proxy-agent/dist/index.js +var require_dist3 = __commonJS({ + "../testeranto/node_modules/https-proxy-agent/dist/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.HttpsProxyAgent = void 0; + var net = __importStar2(__require("net")); + var tls = __importStar2(__require("tls")); + var assert_1 = __importDefault2(__require("assert")); + var debug_1 = __importDefault2(require_src()); + var agent_base_1 = require_dist(); + var url_1 = __require("url"); + var parse_proxy_response_1 = require_parse_proxy_response(); + var debug5 = (0, debug_1.default)("https-proxy-agent"); + var HttpsProxyAgent = class extends agent_base_1.Agent { + constructor(proxy, opts) { + super(opts); + this.options = { path: void 0 }; + this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy; + this.proxyHeaders = opts?.headers ?? {}; + debug5("Creating new HttpsProxyAgent instance: %o", this.proxy.href); + const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, ""); + const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80; + this.connectOpts = { + // Attempt to negotiate http/1.1 for proxy servers that support http/2 + ALPNProtocols: ["http/1.1"], + ...opts ? omit(opts, "headers") : null, + host, + port + }; + } + /** + * Called when the node-core HTTP client library is creating a + * new HTTP request. + */ + async connect(req, opts) { + const { proxy } = this; + if (!opts.host) { + throw new TypeError('No "host" provided'); + } + let socket; + if (proxy.protocol === "https:") { + debug5("Creating `tls.Socket`: %o", this.connectOpts); + const servername = this.connectOpts.servername || this.connectOpts.host; + socket = tls.connect({ + ...this.connectOpts, + servername + }); + } else { + debug5("Creating `net.Socket`: %o", this.connectOpts); + socket = net.connect(this.connectOpts); + } + const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders }; + const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host; + let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r +`; + if (proxy.username || proxy.password) { + const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`; + headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`; + } + headers.Host = `${host}:${opts.port}`; + if (!headers["Proxy-Connection"]) { + headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close"; + } + for (const name of Object.keys(headers)) { + payload += `${name}: ${headers[name]}\r +`; + } + const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket); + socket.write(`${payload}\r +`); + const { connect: connect2, buffered } = await proxyResponsePromise; + req.emit("proxyConnect", connect2); + this.emit("proxyConnect", connect2, req); + if (connect2.statusCode === 200) { + req.once("socket", resume); + if (opts.secureEndpoint) { + debug5("Upgrading socket connection to TLS"); + const servername = opts.servername || opts.host; + return tls.connect({ + ...omit(opts, "host", "path", "port"), + socket, + servername + }); + } + return socket; + } + socket.destroy(); + const fakeSocket = new net.Socket({ writable: false }); + fakeSocket.readable = true; + req.once("socket", (s) => { + debug5("Replaying proxy buffer for failed request"); + (0, assert_1.default)(s.listenerCount("data") > 0); + s.push(buffered); + s.push(null); + }); + return fakeSocket; + } + }; + HttpsProxyAgent.protocols = ["http", "https"]; + exports.HttpsProxyAgent = HttpsProxyAgent; + function resume(socket) { + socket.resume(); + } + function omit(obj, ...keys) { + const ret = {}; + let key; + for (key in obj) { + if (!keys.includes(key)) { + ret[key] = obj[key]; + } + } + return ret; + } + } +}); + +// ../testeranto/node_modules/smart-buffer/build/utils.js +var require_utils2 = __commonJS({ + "../testeranto/node_modules/smart-buffer/build/utils.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var buffer_1 = __require("buffer"); + var ERRORS = { + INVALID_ENCODING: "Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.", + INVALID_SMARTBUFFER_SIZE: "Invalid size provided. Size must be a valid integer greater than zero.", + INVALID_SMARTBUFFER_BUFFER: "Invalid Buffer provided in SmartBufferOptions.", + INVALID_SMARTBUFFER_OBJECT: "Invalid SmartBufferOptions object supplied to SmartBuffer constructor or factory methods.", + INVALID_OFFSET: "An invalid offset value was provided.", + INVALID_OFFSET_NON_NUMBER: "An invalid offset value was provided. A numeric value is required.", + INVALID_LENGTH: "An invalid length value was provided.", + INVALID_LENGTH_NON_NUMBER: "An invalid length value was provived. A numeric value is required.", + INVALID_TARGET_OFFSET: "Target offset is beyond the bounds of the internal SmartBuffer data.", + INVALID_TARGET_LENGTH: "Specified length value moves cursor beyong the bounds of the internal SmartBuffer data.", + INVALID_READ_BEYOND_BOUNDS: "Attempted to read beyond the bounds of the managed data.", + INVALID_WRITE_BEYOND_BOUNDS: "Attempted to write beyond the bounds of the managed data." + }; + exports.ERRORS = ERRORS; + function checkEncoding(encoding) { + if (!buffer_1.Buffer.isEncoding(encoding)) { + throw new Error(ERRORS.INVALID_ENCODING); + } + } + exports.checkEncoding = checkEncoding; + function isFiniteInteger(value) { + return typeof value === "number" && isFinite(value) && isInteger(value); + } + exports.isFiniteInteger = isFiniteInteger; + function checkOffsetOrLengthValue(value, offset) { + if (typeof value === "number") { + if (!isFiniteInteger(value) || value < 0) { + throw new Error(offset ? ERRORS.INVALID_OFFSET : ERRORS.INVALID_LENGTH); + } + } else { + throw new Error(offset ? ERRORS.INVALID_OFFSET_NON_NUMBER : ERRORS.INVALID_LENGTH_NON_NUMBER); + } + } + function checkLengthValue(length) { + checkOffsetOrLengthValue(length, false); + } + exports.checkLengthValue = checkLengthValue; + function checkOffsetValue(offset) { + checkOffsetOrLengthValue(offset, true); + } + exports.checkOffsetValue = checkOffsetValue; + function checkTargetOffset(offset, buff) { + if (offset < 0 || offset > buff.length) { + throw new Error(ERRORS.INVALID_TARGET_OFFSET); + } + } + exports.checkTargetOffset = checkTargetOffset; + function isInteger(value) { + return typeof value === "number" && isFinite(value) && Math.floor(value) === value; + } + function bigIntAndBufferInt64Check(bufferMethod) { + if (typeof BigInt === "undefined") { + throw new Error("Platform does not support JS BigInt type."); + } + if (typeof buffer_1.Buffer.prototype[bufferMethod] === "undefined") { + throw new Error(`Platform does not support Buffer.prototype.${bufferMethod}.`); + } + } + exports.bigIntAndBufferInt64Check = bigIntAndBufferInt64Check; + } +}); + +// ../testeranto/node_modules/smart-buffer/build/smartbuffer.js +var require_smartbuffer = __commonJS({ + "../testeranto/node_modules/smart-buffer/build/smartbuffer.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var utils_1 = require_utils2(); + var DEFAULT_SMARTBUFFER_SIZE = 4096; + var DEFAULT_SMARTBUFFER_ENCODING = "utf8"; + var SmartBuffer = class { + /** + * Creates a new SmartBuffer instance. + * + * @param options { SmartBufferOptions } The SmartBufferOptions to apply to this instance. + */ + constructor(options) { + this.length = 0; + this._encoding = DEFAULT_SMARTBUFFER_ENCODING; + this._writeOffset = 0; + this._readOffset = 0; + if (SmartBuffer.isSmartBufferOptions(options)) { + if (options.encoding) { + utils_1.checkEncoding(options.encoding); + this._encoding = options.encoding; + } + if (options.size) { + if (utils_1.isFiniteInteger(options.size) && options.size > 0) { + this._buff = Buffer.allocUnsafe(options.size); + } else { + throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_SIZE); + } + } else if (options.buff) { + if (Buffer.isBuffer(options.buff)) { + this._buff = options.buff; + this.length = options.buff.length; + } else { + throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_BUFFER); + } + } else { + this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE); + } + } else { + if (typeof options !== "undefined") { + throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_OBJECT); + } + this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE); + } + } + /** + * Creates a new SmartBuffer instance with the provided internal Buffer size and optional encoding. + * + * @param size { Number } The size of the internal Buffer. + * @param encoding { String } The BufferEncoding to use for strings. + * + * @return { SmartBuffer } + */ + static fromSize(size, encoding) { + return new this({ + size, + encoding + }); + } + /** + * Creates a new SmartBuffer instance with the provided Buffer and optional encoding. + * + * @param buffer { Buffer } The Buffer to use as the internal Buffer value. + * @param encoding { String } The BufferEncoding to use for strings. + * + * @return { SmartBuffer } + */ + static fromBuffer(buff, encoding) { + return new this({ + buff, + encoding + }); + } + /** + * Creates a new SmartBuffer instance with the provided SmartBufferOptions options. + * + * @param options { SmartBufferOptions } The options to use when creating the SmartBuffer instance. + */ + static fromOptions(options) { + return new this(options); + } + /** + * Type checking function that determines if an object is a SmartBufferOptions object. + */ + static isSmartBufferOptions(options) { + const castOptions = options; + return castOptions && (castOptions.encoding !== void 0 || castOptions.size !== void 0 || castOptions.buff !== void 0); + } + // Signed integers + /** + * Reads an Int8 value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readInt8(offset) { + return this._readNumberValue(Buffer.prototype.readInt8, 1, offset); + } + /** + * Reads an Int16BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readInt16BE(offset) { + return this._readNumberValue(Buffer.prototype.readInt16BE, 2, offset); + } + /** + * Reads an Int16LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readInt16LE(offset) { + return this._readNumberValue(Buffer.prototype.readInt16LE, 2, offset); + } + /** + * Reads an Int32BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readInt32BE(offset) { + return this._readNumberValue(Buffer.prototype.readInt32BE, 4, offset); + } + /** + * Reads an Int32LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readInt32LE(offset) { + return this._readNumberValue(Buffer.prototype.readInt32LE, 4, offset); + } + /** + * Reads a BigInt64BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { BigInt } + */ + readBigInt64BE(offset) { + utils_1.bigIntAndBufferInt64Check("readBigInt64BE"); + return this._readNumberValue(Buffer.prototype.readBigInt64BE, 8, offset); + } + /** + * Reads a BigInt64LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { BigInt } + */ + readBigInt64LE(offset) { + utils_1.bigIntAndBufferInt64Check("readBigInt64LE"); + return this._readNumberValue(Buffer.prototype.readBigInt64LE, 8, offset); + } + /** + * Writes an Int8 value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt8(value, offset) { + this._writeNumberValue(Buffer.prototype.writeInt8, 1, value, offset); + return this; + } + /** + * Inserts an Int8 value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertInt8(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeInt8, 1, value, offset); + } + /** + * Writes an Int16BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt16BE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset); + } + /** + * Inserts an Int16BE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertInt16BE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset); + } + /** + * Writes an Int16LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt16LE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset); + } + /** + * Inserts an Int16LE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertInt16LE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset); + } + /** + * Writes an Int32BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt32BE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset); + } + /** + * Inserts an Int32BE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertInt32BE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset); + } + /** + * Writes an Int32LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeInt32LE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset); + } + /** + * Inserts an Int32LE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertInt32LE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset); + } + /** + * Writes a BigInt64BE value to the current write position (or at optional offset). + * + * @param value { BigInt } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeBigInt64BE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigInt64BE"); + return this._writeNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset); + } + /** + * Inserts a BigInt64BE value at the given offset value. + * + * @param value { BigInt } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertBigInt64BE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigInt64BE"); + return this._insertNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset); + } + /** + * Writes a BigInt64LE value to the current write position (or at optional offset). + * + * @param value { BigInt } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeBigInt64LE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigInt64LE"); + return this._writeNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset); + } + /** + * Inserts a Int64LE value at the given offset value. + * + * @param value { BigInt } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertBigInt64LE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigInt64LE"); + return this._insertNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset); + } + // Unsigned Integers + /** + * Reads an UInt8 value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readUInt8(offset) { + return this._readNumberValue(Buffer.prototype.readUInt8, 1, offset); + } + /** + * Reads an UInt16BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readUInt16BE(offset) { + return this._readNumberValue(Buffer.prototype.readUInt16BE, 2, offset); + } + /** + * Reads an UInt16LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readUInt16LE(offset) { + return this._readNumberValue(Buffer.prototype.readUInt16LE, 2, offset); + } + /** + * Reads an UInt32BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readUInt32BE(offset) { + return this._readNumberValue(Buffer.prototype.readUInt32BE, 4, offset); + } + /** + * Reads an UInt32LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readUInt32LE(offset) { + return this._readNumberValue(Buffer.prototype.readUInt32LE, 4, offset); + } + /** + * Reads a BigUInt64BE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { BigInt } + */ + readBigUInt64BE(offset) { + utils_1.bigIntAndBufferInt64Check("readBigUInt64BE"); + return this._readNumberValue(Buffer.prototype.readBigUInt64BE, 8, offset); + } + /** + * Reads a BigUInt64LE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { BigInt } + */ + readBigUInt64LE(offset) { + utils_1.bigIntAndBufferInt64Check("readBigUInt64LE"); + return this._readNumberValue(Buffer.prototype.readBigUInt64LE, 8, offset); + } + /** + * Writes an UInt8 value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt8(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeUInt8, 1, value, offset); + } + /** + * Inserts an UInt8 value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertUInt8(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeUInt8, 1, value, offset); + } + /** + * Writes an UInt16BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt16BE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset); + } + /** + * Inserts an UInt16BE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertUInt16BE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset); + } + /** + * Writes an UInt16LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt16LE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset); + } + /** + * Inserts an UInt16LE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertUInt16LE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset); + } + /** + * Writes an UInt32BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt32BE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset); + } + /** + * Inserts an UInt32BE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertUInt32BE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset); + } + /** + * Writes an UInt32LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeUInt32LE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset); + } + /** + * Inserts an UInt32LE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertUInt32LE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset); + } + /** + * Writes a BigUInt64BE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeBigUInt64BE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigUInt64BE"); + return this._writeNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset); + } + /** + * Inserts a BigUInt64BE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertBigUInt64BE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigUInt64BE"); + return this._insertNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset); + } + /** + * Writes a BigUInt64LE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeBigUInt64LE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigUInt64LE"); + return this._writeNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset); + } + /** + * Inserts a BigUInt64LE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertBigUInt64LE(value, offset) { + utils_1.bigIntAndBufferInt64Check("writeBigUInt64LE"); + return this._insertNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset); + } + // Floating Point + /** + * Reads an FloatBE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readFloatBE(offset) { + return this._readNumberValue(Buffer.prototype.readFloatBE, 4, offset); + } + /** + * Reads an FloatLE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readFloatLE(offset) { + return this._readNumberValue(Buffer.prototype.readFloatLE, 4, offset); + } + /** + * Writes a FloatBE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeFloatBE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset); + } + /** + * Inserts a FloatBE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertFloatBE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset); + } + /** + * Writes a FloatLE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeFloatLE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset); + } + /** + * Inserts a FloatLE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertFloatLE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset); + } + // Double Floating Point + /** + * Reads an DoublEBE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readDoubleBE(offset) { + return this._readNumberValue(Buffer.prototype.readDoubleBE, 8, offset); + } + /** + * Reads an DoubleLE value from the current read position or an optionally provided offset. + * + * @param offset { Number } The offset to read data from (optional) + * @return { Number } + */ + readDoubleLE(offset) { + return this._readNumberValue(Buffer.prototype.readDoubleLE, 8, offset); + } + /** + * Writes a DoubleBE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeDoubleBE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset); + } + /** + * Inserts a DoubleBE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertDoubleBE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset); + } + /** + * Writes a DoubleLE value to the current write position (or at optional offset). + * + * @param value { Number } The value to write. + * @param offset { Number } The offset to write the value at. + * + * @return this + */ + writeDoubleLE(value, offset) { + return this._writeNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset); + } + /** + * Inserts a DoubleLE value at the given offset value. + * + * @param value { Number } The value to insert. + * @param offset { Number } The offset to insert the value at. + * + * @return this + */ + insertDoubleLE(value, offset) { + return this._insertNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset); + } + // Strings + /** + * Reads a String from the current read position. + * + * @param arg1 { Number | String } The number of bytes to read as a String, or the BufferEncoding to use for + * the string (Defaults to instance level encoding). + * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding). + * + * @return { String } + */ + readString(arg1, encoding) { + let lengthVal; + if (typeof arg1 === "number") { + utils_1.checkLengthValue(arg1); + lengthVal = Math.min(arg1, this.length - this._readOffset); + } else { + encoding = arg1; + lengthVal = this.length - this._readOffset; + } + if (typeof encoding !== "undefined") { + utils_1.checkEncoding(encoding); + } + const value = this._buff.slice(this._readOffset, this._readOffset + lengthVal).toString(encoding || this._encoding); + this._readOffset += lengthVal; + return value; + } + /** + * Inserts a String + * + * @param value { String } The String value to insert. + * @param offset { Number } The offset to insert the string at. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + * + * @return this + */ + insertString(value, offset, encoding) { + utils_1.checkOffsetValue(offset); + return this._handleString(value, true, offset, encoding); + } + /** + * Writes a String + * + * @param value { String } The String value to write. + * @param arg2 { Number | String } The offset to write the string at, or the BufferEncoding to use. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + * + * @return this + */ + writeString(value, arg2, encoding) { + return this._handleString(value, false, arg2, encoding); + } + /** + * Reads a null-terminated String from the current read position. + * + * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding). + * + * @return { String } + */ + readStringNT(encoding) { + if (typeof encoding !== "undefined") { + utils_1.checkEncoding(encoding); + } + let nullPos = this.length; + for (let i = this._readOffset; i < this.length; i++) { + if (this._buff[i] === 0) { + nullPos = i; + break; + } + } + const value = this._buff.slice(this._readOffset, nullPos); + this._readOffset = nullPos + 1; + return value.toString(encoding || this._encoding); + } + /** + * Inserts a null-terminated String. + * + * @param value { String } The String value to write. + * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + * + * @return this + */ + insertStringNT(value, offset, encoding) { + utils_1.checkOffsetValue(offset); + this.insertString(value, offset, encoding); + this.insertUInt8(0, offset + value.length); + return this; + } + /** + * Writes a null-terminated String. + * + * @param value { String } The String value to write. + * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + * + * @return this + */ + writeStringNT(value, arg2, encoding) { + this.writeString(value, arg2, encoding); + this.writeUInt8(0, typeof arg2 === "number" ? arg2 + value.length : this.writeOffset); + return this; + } + // Buffers + /** + * Reads a Buffer from the internal read position. + * + * @param length { Number } The length of data to read as a Buffer. + * + * @return { Buffer } + */ + readBuffer(length) { + if (typeof length !== "undefined") { + utils_1.checkLengthValue(length); + } + const lengthVal = typeof length === "number" ? length : this.length; + const endPoint = Math.min(this.length, this._readOffset + lengthVal); + const value = this._buff.slice(this._readOffset, endPoint); + this._readOffset = endPoint; + return value; + } + /** + * Writes a Buffer to the current write position. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + * + * @return this + */ + insertBuffer(value, offset) { + utils_1.checkOffsetValue(offset); + return this._handleBuffer(value, true, offset); + } + /** + * Writes a Buffer to the current write position. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + * + * @return this + */ + writeBuffer(value, offset) { + return this._handleBuffer(value, false, offset); + } + /** + * Reads a null-terminated Buffer from the current read poisiton. + * + * @return { Buffer } + */ + readBufferNT() { + let nullPos = this.length; + for (let i = this._readOffset; i < this.length; i++) { + if (this._buff[i] === 0) { + nullPos = i; + break; + } + } + const value = this._buff.slice(this._readOffset, nullPos); + this._readOffset = nullPos + 1; + return value; + } + /** + * Inserts a null-terminated Buffer. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + * + * @return this + */ + insertBufferNT(value, offset) { + utils_1.checkOffsetValue(offset); + this.insertBuffer(value, offset); + this.insertUInt8(0, offset + value.length); + return this; + } + /** + * Writes a null-terminated Buffer. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + * + * @return this + */ + writeBufferNT(value, offset) { + if (typeof offset !== "undefined") { + utils_1.checkOffsetValue(offset); + } + this.writeBuffer(value, offset); + this.writeUInt8(0, typeof offset === "number" ? offset + value.length : this._writeOffset); + return this; + } + /** + * Clears the SmartBuffer instance to its original empty state. + */ + clear() { + this._writeOffset = 0; + this._readOffset = 0; + this.length = 0; + return this; + } + /** + * Gets the remaining data left to be read from the SmartBuffer instance. + * + * @return { Number } + */ + remaining() { + return this.length - this._readOffset; + } + /** + * Gets the current read offset value of the SmartBuffer instance. + * + * @return { Number } + */ + get readOffset() { + return this._readOffset; + } + /** + * Sets the read offset value of the SmartBuffer instance. + * + * @param offset { Number } - The offset value to set. + */ + set readOffset(offset) { + utils_1.checkOffsetValue(offset); + utils_1.checkTargetOffset(offset, this); + this._readOffset = offset; + } + /** + * Gets the current write offset value of the SmartBuffer instance. + * + * @return { Number } + */ + get writeOffset() { + return this._writeOffset; + } + /** + * Sets the write offset value of the SmartBuffer instance. + * + * @param offset { Number } - The offset value to set. + */ + set writeOffset(offset) { + utils_1.checkOffsetValue(offset); + utils_1.checkTargetOffset(offset, this); + this._writeOffset = offset; + } + /** + * Gets the currently set string encoding of the SmartBuffer instance. + * + * @return { BufferEncoding } The string Buffer encoding currently set. + */ + get encoding() { + return this._encoding; + } + /** + * Sets the string encoding of the SmartBuffer instance. + * + * @param encoding { BufferEncoding } The string Buffer encoding to set. + */ + set encoding(encoding) { + utils_1.checkEncoding(encoding); + this._encoding = encoding; + } + /** + * Gets the underlying internal Buffer. (This includes unmanaged data in the Buffer) + * + * @return { Buffer } The Buffer value. + */ + get internalBuffer() { + return this._buff; + } + /** + * Gets the value of the internal managed Buffer (Includes managed data only) + * + * @param { Buffer } + */ + toBuffer() { + return this._buff.slice(0, this.length); + } + /** + * Gets the String value of the internal managed Buffer + * + * @param encoding { String } The BufferEncoding to display the Buffer as (defaults to instance level encoding). + */ + toString(encoding) { + const encodingVal = typeof encoding === "string" ? encoding : this._encoding; + utils_1.checkEncoding(encodingVal); + return this._buff.toString(encodingVal, 0, this.length); + } + /** + * Destroys the SmartBuffer instance. + */ + destroy() { + this.clear(); + return this; + } + /** + * Handles inserting and writing strings. + * + * @param value { String } The String value to insert. + * @param isInsert { Boolean } True if inserting a string, false if writing. + * @param arg2 { Number | String } The offset to insert the string at, or the BufferEncoding to use. + * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). + */ + _handleString(value, isInsert, arg3, encoding) { + let offsetVal = this._writeOffset; + let encodingVal = this._encoding; + if (typeof arg3 === "number") { + offsetVal = arg3; + } else if (typeof arg3 === "string") { + utils_1.checkEncoding(arg3); + encodingVal = arg3; + } + if (typeof encoding === "string") { + utils_1.checkEncoding(encoding); + encodingVal = encoding; + } + const byteLength = Buffer.byteLength(value, encodingVal); + if (isInsert) { + this.ensureInsertable(byteLength, offsetVal); + } else { + this._ensureWriteable(byteLength, offsetVal); + } + this._buff.write(value, offsetVal, byteLength, encodingVal); + if (isInsert) { + this._writeOffset += byteLength; + } else { + if (typeof arg3 === "number") { + this._writeOffset = Math.max(this._writeOffset, offsetVal + byteLength); + } else { + this._writeOffset += byteLength; + } + } + return this; + } + /** + * Handles writing or insert of a Buffer. + * + * @param value { Buffer } The Buffer to write. + * @param offset { Number } The offset to write the Buffer to. + */ + _handleBuffer(value, isInsert, offset) { + const offsetVal = typeof offset === "number" ? offset : this._writeOffset; + if (isInsert) { + this.ensureInsertable(value.length, offsetVal); + } else { + this._ensureWriteable(value.length, offsetVal); + } + value.copy(this._buff, offsetVal); + if (isInsert) { + this._writeOffset += value.length; + } else { + if (typeof offset === "number") { + this._writeOffset = Math.max(this._writeOffset, offsetVal + value.length); + } else { + this._writeOffset += value.length; + } + } + return this; + } + /** + * Ensures that the internal Buffer is large enough to read data. + * + * @param length { Number } The length of the data that needs to be read. + * @param offset { Number } The offset of the data that needs to be read. + */ + ensureReadable(length, offset) { + let offsetVal = this._readOffset; + if (typeof offset !== "undefined") { + utils_1.checkOffsetValue(offset); + offsetVal = offset; + } + if (offsetVal < 0 || offsetVal + length > this.length) { + throw new Error(utils_1.ERRORS.INVALID_READ_BEYOND_BOUNDS); + } + } + /** + * Ensures that the internal Buffer is large enough to insert data. + * + * @param dataLength { Number } The length of the data that needs to be written. + * @param offset { Number } The offset of the data to be written. + */ + ensureInsertable(dataLength, offset) { + utils_1.checkOffsetValue(offset); + this._ensureCapacity(this.length + dataLength); + if (offset < this.length) { + this._buff.copy(this._buff, offset + dataLength, offset, this._buff.length); + } + if (offset + dataLength > this.length) { + this.length = offset + dataLength; + } else { + this.length += dataLength; + } + } + /** + * Ensures that the internal Buffer is large enough to write data. + * + * @param dataLength { Number } The length of the data that needs to be written. + * @param offset { Number } The offset of the data to be written (defaults to writeOffset). + */ + _ensureWriteable(dataLength, offset) { + const offsetVal = typeof offset === "number" ? offset : this._writeOffset; + this._ensureCapacity(offsetVal + dataLength); + if (offsetVal + dataLength > this.length) { + this.length = offsetVal + dataLength; + } + } + /** + * Ensures that the internal Buffer is large enough to write at least the given amount of data. + * + * @param minLength { Number } The minimum length of the data needs to be written. + */ + _ensureCapacity(minLength) { + const oldLength = this._buff.length; + if (minLength > oldLength) { + let data = this._buff; + let newLength = oldLength * 3 / 2 + 1; + if (newLength < minLength) { + newLength = minLength; + } + this._buff = Buffer.allocUnsafe(newLength); + data.copy(this._buff, 0, 0, oldLength); + } + } + /** + * Reads a numeric number value using the provided function. + * + * @typeparam T { number | bigint } The type of the value to be read + * + * @param func { Function(offset: number) => number } The function to read data on the internal Buffer with. + * @param byteSize { Number } The number of bytes read. + * @param offset { Number } The offset to read from (optional). When this is not provided, the managed readOffset is used instead. + * + * @returns { T } the number value + */ + _readNumberValue(func, byteSize, offset) { + this.ensureReadable(byteSize, offset); + const value = func.call(this._buff, typeof offset === "number" ? offset : this._readOffset); + if (typeof offset === "undefined") { + this._readOffset += byteSize; + } + return value; + } + /** + * Inserts a numeric number value based on the given offset and value. + * + * @typeparam T { number | bigint } The type of the value to be written + * + * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with. + * @param byteSize { Number } The number of bytes written. + * @param value { T } The number value to write. + * @param offset { Number } the offset to write the number at (REQUIRED). + * + * @returns SmartBuffer this buffer + */ + _insertNumberValue(func, byteSize, value, offset) { + utils_1.checkOffsetValue(offset); + this.ensureInsertable(byteSize, offset); + func.call(this._buff, value, offset); + this._writeOffset += byteSize; + return this; + } + /** + * Writes a numeric number value based on the given offset and value. + * + * @typeparam T { number | bigint } The type of the value to be written + * + * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with. + * @param byteSize { Number } The number of bytes written. + * @param value { T } The number value to write. + * @param offset { Number } the offset to write the number at (REQUIRED). + * + * @returns SmartBuffer this buffer + */ + _writeNumberValue(func, byteSize, value, offset) { + if (typeof offset === "number") { + if (offset < 0) { + throw new Error(utils_1.ERRORS.INVALID_WRITE_BEYOND_BOUNDS); + } + utils_1.checkOffsetValue(offset); + } + const offsetVal = typeof offset === "number" ? offset : this._writeOffset; + this._ensureWriteable(byteSize, offsetVal); + func.call(this._buff, value, offsetVal); + if (typeof offset === "number") { + this._writeOffset = Math.max(this._writeOffset, offsetVal + byteSize); + } else { + this._writeOffset += byteSize; + } + return this; + } + }; + exports.SmartBuffer = SmartBuffer; + } +}); + +// ../testeranto/node_modules/socks/build/common/constants.js +var require_constants2 = __commonJS({ + "../testeranto/node_modules/socks/build/common/constants.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SOCKS5_NO_ACCEPTABLE_AUTH = exports.SOCKS5_CUSTOM_AUTH_END = exports.SOCKS5_CUSTOM_AUTH_START = exports.SOCKS_INCOMING_PACKET_SIZES = exports.SocksClientState = exports.Socks5Response = exports.Socks5HostType = exports.Socks5Auth = exports.Socks4Response = exports.SocksCommand = exports.ERRORS = exports.DEFAULT_TIMEOUT = void 0; + var DEFAULT_TIMEOUT = 3e4; + exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT; + var ERRORS = { + InvalidSocksCommand: "An invalid SOCKS command was provided. Valid options are connect, bind, and associate.", + InvalidSocksCommandForOperation: "An invalid SOCKS command was provided. Only a subset of commands are supported for this operation.", + InvalidSocksCommandChain: "An invalid SOCKS command was provided. Chaining currently only supports the connect command.", + InvalidSocksClientOptionsDestination: "An invalid destination host was provided.", + InvalidSocksClientOptionsExistingSocket: "An invalid existing socket was provided. This should be an instance of stream.Duplex.", + InvalidSocksClientOptionsProxy: "Invalid SOCKS proxy details were provided.", + InvalidSocksClientOptionsTimeout: "An invalid timeout value was provided. Please enter a value above 0 (in ms).", + InvalidSocksClientOptionsProxiesLength: "At least two socks proxies must be provided for chaining.", + InvalidSocksClientOptionsCustomAuthRange: "Custom auth must be a value between 0x80 and 0xFE.", + InvalidSocksClientOptionsCustomAuthOptions: "When a custom_auth_method is provided, custom_auth_request_handler, custom_auth_response_size, and custom_auth_response_handler must also be provided and valid.", + NegotiationError: "Negotiation error", + SocketClosed: "Socket closed", + ProxyConnectionTimedOut: "Proxy connection timed out", + InternalError: "SocksClient internal error (this should not happen)", + InvalidSocks4HandshakeResponse: "Received invalid Socks4 handshake response", + Socks4ProxyRejectedConnection: "Socks4 Proxy rejected connection", + InvalidSocks4IncomingConnectionResponse: "Socks4 invalid incoming connection response", + Socks4ProxyRejectedIncomingBoundConnection: "Socks4 Proxy rejected incoming bound connection", + InvalidSocks5InitialHandshakeResponse: "Received invalid Socks5 initial handshake response", + InvalidSocks5IntiailHandshakeSocksVersion: "Received invalid Socks5 initial handshake (invalid socks version)", + InvalidSocks5InitialHandshakeNoAcceptedAuthType: "Received invalid Socks5 initial handshake (no accepted authentication type)", + InvalidSocks5InitialHandshakeUnknownAuthType: "Received invalid Socks5 initial handshake (unknown authentication type)", + Socks5AuthenticationFailed: "Socks5 Authentication failed", + InvalidSocks5FinalHandshake: "Received invalid Socks5 final handshake response", + InvalidSocks5FinalHandshakeRejected: "Socks5 proxy rejected connection", + InvalidSocks5IncomingConnectionResponse: "Received invalid Socks5 incoming connection response", + Socks5ProxyRejectedIncomingBoundConnection: "Socks5 Proxy rejected incoming bound connection" + }; + exports.ERRORS = ERRORS; + var SOCKS_INCOMING_PACKET_SIZES = { + Socks5InitialHandshakeResponse: 2, + Socks5UserPassAuthenticationResponse: 2, + // Command response + incoming connection (bind) + Socks5ResponseHeader: 5, + // We need at least 5 to read the hostname length, then we wait for the address+port information. + Socks5ResponseIPv4: 10, + // 4 header + 4 ip + 2 port + Socks5ResponseIPv6: 22, + // 4 header + 16 ip + 2 port + Socks5ResponseHostname: (hostNameLength) => hostNameLength + 7, + // 4 header + 1 host length + host + 2 port + // Command response + incoming connection (bind) + Socks4Response: 8 + // 2 header + 2 port + 4 ip + }; + exports.SOCKS_INCOMING_PACKET_SIZES = SOCKS_INCOMING_PACKET_SIZES; + var SocksCommand; + (function(SocksCommand2) { + SocksCommand2[SocksCommand2["connect"] = 1] = "connect"; + SocksCommand2[SocksCommand2["bind"] = 2] = "bind"; + SocksCommand2[SocksCommand2["associate"] = 3] = "associate"; + })(SocksCommand || (exports.SocksCommand = SocksCommand = {})); + var Socks4Response; + (function(Socks4Response2) { + Socks4Response2[Socks4Response2["Granted"] = 90] = "Granted"; + Socks4Response2[Socks4Response2["Failed"] = 91] = "Failed"; + Socks4Response2[Socks4Response2["Rejected"] = 92] = "Rejected"; + Socks4Response2[Socks4Response2["RejectedIdent"] = 93] = "RejectedIdent"; + })(Socks4Response || (exports.Socks4Response = Socks4Response = {})); + var Socks5Auth; + (function(Socks5Auth2) { + Socks5Auth2[Socks5Auth2["NoAuth"] = 0] = "NoAuth"; + Socks5Auth2[Socks5Auth2["GSSApi"] = 1] = "GSSApi"; + Socks5Auth2[Socks5Auth2["UserPass"] = 2] = "UserPass"; + })(Socks5Auth || (exports.Socks5Auth = Socks5Auth = {})); + var SOCKS5_CUSTOM_AUTH_START = 128; + exports.SOCKS5_CUSTOM_AUTH_START = SOCKS5_CUSTOM_AUTH_START; + var SOCKS5_CUSTOM_AUTH_END = 254; + exports.SOCKS5_CUSTOM_AUTH_END = SOCKS5_CUSTOM_AUTH_END; + var SOCKS5_NO_ACCEPTABLE_AUTH = 255; + exports.SOCKS5_NO_ACCEPTABLE_AUTH = SOCKS5_NO_ACCEPTABLE_AUTH; + var Socks5Response; + (function(Socks5Response2) { + Socks5Response2[Socks5Response2["Granted"] = 0] = "Granted"; + Socks5Response2[Socks5Response2["Failure"] = 1] = "Failure"; + Socks5Response2[Socks5Response2["NotAllowed"] = 2] = "NotAllowed"; + Socks5Response2[Socks5Response2["NetworkUnreachable"] = 3] = "NetworkUnreachable"; + Socks5Response2[Socks5Response2["HostUnreachable"] = 4] = "HostUnreachable"; + Socks5Response2[Socks5Response2["ConnectionRefused"] = 5] = "ConnectionRefused"; + Socks5Response2[Socks5Response2["TTLExpired"] = 6] = "TTLExpired"; + Socks5Response2[Socks5Response2["CommandNotSupported"] = 7] = "CommandNotSupported"; + Socks5Response2[Socks5Response2["AddressNotSupported"] = 8] = "AddressNotSupported"; + })(Socks5Response || (exports.Socks5Response = Socks5Response = {})); + var Socks5HostType; + (function(Socks5HostType2) { + Socks5HostType2[Socks5HostType2["IPv4"] = 1] = "IPv4"; + Socks5HostType2[Socks5HostType2["Hostname"] = 3] = "Hostname"; + Socks5HostType2[Socks5HostType2["IPv6"] = 4] = "IPv6"; + })(Socks5HostType || (exports.Socks5HostType = Socks5HostType = {})); + var SocksClientState; + (function(SocksClientState2) { + SocksClientState2[SocksClientState2["Created"] = 0] = "Created"; + SocksClientState2[SocksClientState2["Connecting"] = 1] = "Connecting"; + SocksClientState2[SocksClientState2["Connected"] = 2] = "Connected"; + SocksClientState2[SocksClientState2["SentInitialHandshake"] = 3] = "SentInitialHandshake"; + SocksClientState2[SocksClientState2["ReceivedInitialHandshakeResponse"] = 4] = "ReceivedInitialHandshakeResponse"; + SocksClientState2[SocksClientState2["SentAuthentication"] = 5] = "SentAuthentication"; + SocksClientState2[SocksClientState2["ReceivedAuthenticationResponse"] = 6] = "ReceivedAuthenticationResponse"; + SocksClientState2[SocksClientState2["SentFinalHandshake"] = 7] = "SentFinalHandshake"; + SocksClientState2[SocksClientState2["ReceivedFinalResponse"] = 8] = "ReceivedFinalResponse"; + SocksClientState2[SocksClientState2["BoundWaitingForConnection"] = 9] = "BoundWaitingForConnection"; + SocksClientState2[SocksClientState2["Established"] = 10] = "Established"; + SocksClientState2[SocksClientState2["Disconnected"] = 11] = "Disconnected"; + SocksClientState2[SocksClientState2["Error"] = 99] = "Error"; + })(SocksClientState || (exports.SocksClientState = SocksClientState = {})); + } +}); + +// ../testeranto/node_modules/socks/build/common/util.js +var require_util = __commonJS({ + "../testeranto/node_modules/socks/build/common/util.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.shuffleArray = exports.SocksClientError = void 0; + var SocksClientError = class extends Error { + constructor(message, options) { + super(message); + this.options = options; + } + }; + exports.SocksClientError = SocksClientError; + function shuffleArray(array) { + for (let i = array.length - 1; i > 0; i--) { + const j = Math.floor(Math.random() * (i + 1)); + [array[i], array[j]] = [array[j], array[i]]; + } + } + exports.shuffleArray = shuffleArray; + } +}); + +// ../testeranto/node_modules/ip-address/dist/common.js +var require_common = __commonJS({ + "../testeranto/node_modules/ip-address/dist/common.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isCorrect = exports.isInSubnet = void 0; + function isInSubnet(address) { + if (this.subnetMask < address.subnetMask) { + return false; + } + if (this.mask(address.subnetMask) === address.mask()) { + return true; + } + return false; + } + exports.isInSubnet = isInSubnet; + function isCorrect(defaultBits) { + return function() { + if (this.addressMinusSuffix !== this.correctForm()) { + return false; + } + if (this.subnetMask === defaultBits && !this.parsedSubnet) { + return true; + } + return this.parsedSubnet === String(this.subnetMask); + }; + } + exports.isCorrect = isCorrect; + } +}); + +// ../testeranto/node_modules/ip-address/dist/v4/constants.js +var require_constants3 = __commonJS({ + "../testeranto/node_modules/ip-address/dist/v4/constants.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.RE_SUBNET_STRING = exports.RE_ADDRESS = exports.GROUPS = exports.BITS = void 0; + exports.BITS = 32; + exports.GROUPS = 4; + exports.RE_ADDRESS = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/g; + exports.RE_SUBNET_STRING = /\/\d{1,2}$/; + } +}); + +// ../testeranto/node_modules/ip-address/dist/address-error.js +var require_address_error = __commonJS({ + "../testeranto/node_modules/ip-address/dist/address-error.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AddressError = void 0; + var AddressError = class extends Error { + constructor(message, parseMessage) { + super(message); + this.name = "AddressError"; + if (parseMessage !== null) { + this.parseMessage = parseMessage; + } + } + }; + exports.AddressError = AddressError; + } +}); + +// ../testeranto/node_modules/jsbn/index.js +var require_jsbn = __commonJS({ + "../testeranto/node_modules/jsbn/index.js"(exports, module) { + init_cjs_shim(); + (function() { + var dbits; + var canary = 244837814094590; + var j_lm = (canary & 16777215) == 15715070; + function BigInteger(a, b, c) { + if (a != null) + if ("number" == typeof a) + this.fromNumber(a, b, c); + else if (b == null && "string" != typeof a) + this.fromString(a, 256); + else + this.fromString(a, b); + } + function nbi() { + return new BigInteger(null); + } + function am1(i, x, w, j, c, n) { + while (--n >= 0) { + var v = x * this[i++] + w[j] + c; + c = Math.floor(v / 67108864); + w[j++] = v & 67108863; + } + return c; + } + function am2(i, x, w, j, c, n) { + var xl = x & 32767, xh = x >> 15; + while (--n >= 0) { + var l = this[i] & 32767; + var h = this[i++] >> 15; + var m = xh * l + h * xl; + l = xl * l + ((m & 32767) << 15) + w[j] + (c & 1073741823); + c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30); + w[j++] = l & 1073741823; + } + return c; + } + function am3(i, x, w, j, c, n) { + var xl = x & 16383, xh = x >> 14; + while (--n >= 0) { + var l = this[i] & 16383; + var h = this[i++] >> 14; + var m = xh * l + h * xl; + l = xl * l + ((m & 16383) << 14) + w[j] + c; + c = (l >> 28) + (m >> 14) + xh * h; + w[j++] = l & 268435455; + } + return c; + } + var inBrowser = typeof navigator !== "undefined"; + if (inBrowser && j_lm && navigator.appName == "Microsoft Internet Explorer") { + BigInteger.prototype.am = am2; + dbits = 30; + } else if (inBrowser && j_lm && navigator.appName != "Netscape") { + BigInteger.prototype.am = am1; + dbits = 26; + } else { + BigInteger.prototype.am = am3; + dbits = 28; + } + BigInteger.prototype.DB = dbits; + BigInteger.prototype.DM = (1 << dbits) - 1; + BigInteger.prototype.DV = 1 << dbits; + var BI_FP = 52; + BigInteger.prototype.FV = Math.pow(2, BI_FP); + BigInteger.prototype.F1 = BI_FP - dbits; + BigInteger.prototype.F2 = 2 * dbits - BI_FP; + var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz"; + var BI_RC = new Array(); + var rr, vv; + rr = "0".charCodeAt(0); + for (vv = 0; vv <= 9; ++vv) + BI_RC[rr++] = vv; + rr = "a".charCodeAt(0); + for (vv = 10; vv < 36; ++vv) + BI_RC[rr++] = vv; + rr = "A".charCodeAt(0); + for (vv = 10; vv < 36; ++vv) + BI_RC[rr++] = vv; + function int2char(n) { + return BI_RM.charAt(n); + } + function intAt(s, i) { + var c = BI_RC[s.charCodeAt(i)]; + return c == null ? -1 : c; + } + function bnpCopyTo(r) { + for (var i = this.t - 1; i >= 0; --i) + r[i] = this[i]; + r.t = this.t; + r.s = this.s; + } + function bnpFromInt(x) { + this.t = 1; + this.s = x < 0 ? -1 : 0; + if (x > 0) + this[0] = x; + else if (x < -1) + this[0] = x + this.DV; + else + this.t = 0; + } + function nbv(i) { + var r = nbi(); + r.fromInt(i); + return r; + } + function bnpFromString(s, b) { + var k; + if (b == 16) + k = 4; + else if (b == 8) + k = 3; + else if (b == 256) + k = 8; + else if (b == 2) + k = 1; + else if (b == 32) + k = 5; + else if (b == 4) + k = 2; + else { + this.fromRadix(s, b); + return; + } + this.t = 0; + this.s = 0; + var i = s.length, mi = false, sh = 0; + while (--i >= 0) { + var x = k == 8 ? s[i] & 255 : intAt(s, i); + if (x < 0) { + if (s.charAt(i) == "-") + mi = true; + continue; + } + mi = false; + if (sh == 0) + this[this.t++] = x; + else if (sh + k > this.DB) { + this[this.t - 1] |= (x & (1 << this.DB - sh) - 1) << sh; + this[this.t++] = x >> this.DB - sh; + } else + this[this.t - 1] |= x << sh; + sh += k; + if (sh >= this.DB) + sh -= this.DB; + } + if (k == 8 && (s[0] & 128) != 0) { + this.s = -1; + if (sh > 0) + this[this.t - 1] |= (1 << this.DB - sh) - 1 << sh; + } + this.clamp(); + if (mi) + BigInteger.ZERO.subTo(this, this); + } + function bnpClamp() { + var c = this.s & this.DM; + while (this.t > 0 && this[this.t - 1] == c) + --this.t; + } + function bnToString(b) { + if (this.s < 0) + return "-" + this.negate().toString(b); + var k; + if (b == 16) + k = 4; + else if (b == 8) + k = 3; + else if (b == 2) + k = 1; + else if (b == 32) + k = 5; + else if (b == 4) + k = 2; + else + return this.toRadix(b); + var km = (1 << k) - 1, d, m = false, r = "", i = this.t; + var p = this.DB - i * this.DB % k; + if (i-- > 0) { + if (p < this.DB && (d = this[i] >> p) > 0) { + m = true; + r = int2char(d); + } + while (i >= 0) { + if (p < k) { + d = (this[i] & (1 << p) - 1) << k - p; + d |= this[--i] >> (p += this.DB - k); + } else { + d = this[i] >> (p -= k) & km; + if (p <= 0) { + p += this.DB; + --i; + } + } + if (d > 0) + m = true; + if (m) + r += int2char(d); + } + } + return m ? r : "0"; + } + function bnNegate() { + var r = nbi(); + BigInteger.ZERO.subTo(this, r); + return r; + } + function bnAbs() { + return this.s < 0 ? this.negate() : this; + } + function bnCompareTo(a) { + var r = this.s - a.s; + if (r != 0) + return r; + var i = this.t; + r = i - a.t; + if (r != 0) + return this.s < 0 ? -r : r; + while (--i >= 0) + if ((r = this[i] - a[i]) != 0) + return r; + return 0; + } + function nbits(x) { + var r = 1, t2; + if ((t2 = x >>> 16) != 0) { + x = t2; + r += 16; + } + if ((t2 = x >> 8) != 0) { + x = t2; + r += 8; + } + if ((t2 = x >> 4) != 0) { + x = t2; + r += 4; + } + if ((t2 = x >> 2) != 0) { + x = t2; + r += 2; + } + if ((t2 = x >> 1) != 0) { + x = t2; + r += 1; + } + return r; + } + function bnBitLength() { + if (this.t <= 0) + return 0; + return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM); + } + function bnpDLShiftTo(n, r) { + var i; + for (i = this.t - 1; i >= 0; --i) + r[i + n] = this[i]; + for (i = n - 1; i >= 0; --i) + r[i] = 0; + r.t = this.t + n; + r.s = this.s; + } + function bnpDRShiftTo(n, r) { + for (var i = n; i < this.t; ++i) + r[i - n] = this[i]; + r.t = Math.max(this.t - n, 0); + r.s = this.s; + } + function bnpLShiftTo(n, r) { + var bs = n % this.DB; + var cbs = this.DB - bs; + var bm = (1 << cbs) - 1; + var ds = Math.floor(n / this.DB), c = this.s << bs & this.DM, i; + for (i = this.t - 1; i >= 0; --i) { + r[i + ds + 1] = this[i] >> cbs | c; + c = (this[i] & bm) << bs; + } + for (i = ds - 1; i >= 0; --i) + r[i] = 0; + r[ds] = c; + r.t = this.t + ds + 1; + r.s = this.s; + r.clamp(); + } + function bnpRShiftTo(n, r) { + r.s = this.s; + var ds = Math.floor(n / this.DB); + if (ds >= this.t) { + r.t = 0; + return; + } + var bs = n % this.DB; + var cbs = this.DB - bs; + var bm = (1 << bs) - 1; + r[0] = this[ds] >> bs; + for (var i = ds + 1; i < this.t; ++i) { + r[i - ds - 1] |= (this[i] & bm) << cbs; + r[i - ds] = this[i] >> bs; + } + if (bs > 0) + r[this.t - ds - 1] |= (this.s & bm) << cbs; + r.t = this.t - ds; + r.clamp(); + } + function bnpSubTo(a, r) { + var i = 0, c = 0, m = Math.min(a.t, this.t); + while (i < m) { + c += this[i] - a[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + if (a.t < this.t) { + c -= a.s; + while (i < this.t) { + c += this[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + c += this.s; + } else { + c += this.s; + while (i < a.t) { + c -= a[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + c -= a.s; + } + r.s = c < 0 ? -1 : 0; + if (c < -1) + r[i++] = this.DV + c; + else if (c > 0) + r[i++] = c; + r.t = i; + r.clamp(); + } + function bnpMultiplyTo(a, r) { + var x = this.abs(), y = a.abs(); + var i = x.t; + r.t = i + y.t; + while (--i >= 0) + r[i] = 0; + for (i = 0; i < y.t; ++i) + r[i + x.t] = x.am(0, y[i], r, i, 0, x.t); + r.s = 0; + r.clamp(); + if (this.s != a.s) + BigInteger.ZERO.subTo(r, r); + } + function bnpSquareTo(r) { + var x = this.abs(); + var i = r.t = 2 * x.t; + while (--i >= 0) + r[i] = 0; + for (i = 0; i < x.t - 1; ++i) { + var c = x.am(i, x[i], r, 2 * i, 0, 1); + if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) { + r[i + x.t] -= x.DV; + r[i + x.t + 1] = 1; + } + } + if (r.t > 0) + r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1); + r.s = 0; + r.clamp(); + } + function bnpDivRemTo(m, q, r) { + var pm = m.abs(); + if (pm.t <= 0) + return; + var pt = this.abs(); + if (pt.t < pm.t) { + if (q != null) + q.fromInt(0); + if (r != null) + this.copyTo(r); + return; + } + if (r == null) + r = nbi(); + var y = nbi(), ts = this.s, ms = m.s; + var nsh = this.DB - nbits(pm[pm.t - 1]); + if (nsh > 0) { + pm.lShiftTo(nsh, y); + pt.lShiftTo(nsh, r); + } else { + pm.copyTo(y); + pt.copyTo(r); + } + var ys = y.t; + var y0 = y[ys - 1]; + if (y0 == 0) + return; + var yt = y0 * (1 << this.F1) + (ys > 1 ? y[ys - 2] >> this.F2 : 0); + var d1 = this.FV / yt, d2 = (1 << this.F1) / yt, e = 1 << this.F2; + var i = r.t, j = i - ys, t2 = q == null ? nbi() : q; + y.dlShiftTo(j, t2); + if (r.compareTo(t2) >= 0) { + r[r.t++] = 1; + r.subTo(t2, r); + } + BigInteger.ONE.dlShiftTo(ys, t2); + t2.subTo(y, y); + while (y.t < ys) + y[y.t++] = 0; + while (--j >= 0) { + var qd = r[--i] == y0 ? this.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2); + if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) { + y.dlShiftTo(j, t2); + r.subTo(t2, r); + while (r[i] < --qd) + r.subTo(t2, r); + } + } + if (q != null) { + r.drShiftTo(ys, q); + if (ts != ms) + BigInteger.ZERO.subTo(q, q); + } + r.t = ys; + r.clamp(); + if (nsh > 0) + r.rShiftTo(nsh, r); + if (ts < 0) + BigInteger.ZERO.subTo(r, r); + } + function bnMod(a) { + var r = nbi(); + this.abs().divRemTo(a, null, r); + if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) + a.subTo(r, r); + return r; + } + function Classic(m) { + this.m = m; + } + function cConvert(x) { + if (x.s < 0 || x.compareTo(this.m) >= 0) + return x.mod(this.m); + else + return x; + } + function cRevert(x) { + return x; + } + function cReduce(x) { + x.divRemTo(this.m, null, x); + } + function cMulTo(x, y, r) { + x.multiplyTo(y, r); + this.reduce(r); + } + function cSqrTo(x, r) { + x.squareTo(r); + this.reduce(r); + } + Classic.prototype.convert = cConvert; + Classic.prototype.revert = cRevert; + Classic.prototype.reduce = cReduce; + Classic.prototype.mulTo = cMulTo; + Classic.prototype.sqrTo = cSqrTo; + function bnpInvDigit() { + if (this.t < 1) + return 0; + var x = this[0]; + if ((x & 1) == 0) + return 0; + var y = x & 3; + y = y * (2 - (x & 15) * y) & 15; + y = y * (2 - (x & 255) * y) & 255; + y = y * (2 - ((x & 65535) * y & 65535)) & 65535; + y = y * (2 - x * y % this.DV) % this.DV; + return y > 0 ? this.DV - y : -y; + } + function Montgomery(m) { + this.m = m; + this.mp = m.invDigit(); + this.mpl = this.mp & 32767; + this.mph = this.mp >> 15; + this.um = (1 << m.DB - 15) - 1; + this.mt2 = 2 * m.t; + } + function montConvert(x) { + var r = nbi(); + x.abs().dlShiftTo(this.m.t, r); + r.divRemTo(this.m, null, r); + if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) + this.m.subTo(r, r); + return r; + } + function montRevert(x) { + var r = nbi(); + x.copyTo(r); + this.reduce(r); + return r; + } + function montReduce(x) { + while (x.t <= this.mt2) + x[x.t++] = 0; + for (var i = 0; i < this.m.t; ++i) { + var j = x[i] & 32767; + var u0 = j * this.mpl + ((j * this.mph + (x[i] >> 15) * this.mpl & this.um) << 15) & x.DM; + j = i + this.m.t; + x[j] += this.m.am(0, u0, x, i, 0, this.m.t); + while (x[j] >= x.DV) { + x[j] -= x.DV; + x[++j]++; + } + } + x.clamp(); + x.drShiftTo(this.m.t, x); + if (x.compareTo(this.m) >= 0) + x.subTo(this.m, x); + } + function montSqrTo(x, r) { + x.squareTo(r); + this.reduce(r); + } + function montMulTo(x, y, r) { + x.multiplyTo(y, r); + this.reduce(r); + } + Montgomery.prototype.convert = montConvert; + Montgomery.prototype.revert = montRevert; + Montgomery.prototype.reduce = montReduce; + Montgomery.prototype.mulTo = montMulTo; + Montgomery.prototype.sqrTo = montSqrTo; + function bnpIsEven() { + return (this.t > 0 ? this[0] & 1 : this.s) == 0; + } + function bnpExp(e, z2) { + if (e > 4294967295 || e < 1) + return BigInteger.ONE; + var r = nbi(), r2 = nbi(), g = z2.convert(this), i = nbits(e) - 1; + g.copyTo(r); + while (--i >= 0) { + z2.sqrTo(r, r2); + if ((e & 1 << i) > 0) + z2.mulTo(r2, g, r); + else { + var t2 = r; + r = r2; + r2 = t2; + } + } + return z2.revert(r); + } + function bnModPowInt(e, m) { + var z2; + if (e < 256 || m.isEven()) + z2 = new Classic(m); + else + z2 = new Montgomery(m); + return this.exp(e, z2); + } + BigInteger.prototype.copyTo = bnpCopyTo; + BigInteger.prototype.fromInt = bnpFromInt; + BigInteger.prototype.fromString = bnpFromString; + BigInteger.prototype.clamp = bnpClamp; + BigInteger.prototype.dlShiftTo = bnpDLShiftTo; + BigInteger.prototype.drShiftTo = bnpDRShiftTo; + BigInteger.prototype.lShiftTo = bnpLShiftTo; + BigInteger.prototype.rShiftTo = bnpRShiftTo; + BigInteger.prototype.subTo = bnpSubTo; + BigInteger.prototype.multiplyTo = bnpMultiplyTo; + BigInteger.prototype.squareTo = bnpSquareTo; + BigInteger.prototype.divRemTo = bnpDivRemTo; + BigInteger.prototype.invDigit = bnpInvDigit; + BigInteger.prototype.isEven = bnpIsEven; + BigInteger.prototype.exp = bnpExp; + BigInteger.prototype.toString = bnToString; + BigInteger.prototype.negate = bnNegate; + BigInteger.prototype.abs = bnAbs; + BigInteger.prototype.compareTo = bnCompareTo; + BigInteger.prototype.bitLength = bnBitLength; + BigInteger.prototype.mod = bnMod; + BigInteger.prototype.modPowInt = bnModPowInt; + BigInteger.ZERO = nbv(0); + BigInteger.ONE = nbv(1); + function bnClone() { + var r = nbi(); + this.copyTo(r); + return r; + } + function bnIntValue() { + if (this.s < 0) { + if (this.t == 1) + return this[0] - this.DV; + else if (this.t == 0) + return -1; + } else if (this.t == 1) + return this[0]; + else if (this.t == 0) + return 0; + return (this[1] & (1 << 32 - this.DB) - 1) << this.DB | this[0]; + } + function bnByteValue() { + return this.t == 0 ? this.s : this[0] << 24 >> 24; + } + function bnShortValue() { + return this.t == 0 ? this.s : this[0] << 16 >> 16; + } + function bnpChunkSize(r) { + return Math.floor(Math.LN2 * this.DB / Math.log(r)); + } + function bnSigNum() { + if (this.s < 0) + return -1; + else if (this.t <= 0 || this.t == 1 && this[0] <= 0) + return 0; + else + return 1; + } + function bnpToRadix(b) { + if (b == null) + b = 10; + if (this.signum() == 0 || b < 2 || b > 36) + return "0"; + var cs = this.chunkSize(b); + var a = Math.pow(b, cs); + var d = nbv(a), y = nbi(), z2 = nbi(), r = ""; + this.divRemTo(d, y, z2); + while (y.signum() > 0) { + r = (a + z2.intValue()).toString(b).substr(1) + r; + y.divRemTo(d, y, z2); + } + return z2.intValue().toString(b) + r; + } + function bnpFromRadix(s, b) { + this.fromInt(0); + if (b == null) + b = 10; + var cs = this.chunkSize(b); + var d = Math.pow(b, cs), mi = false, j = 0, w = 0; + for (var i = 0; i < s.length; ++i) { + var x = intAt(s, i); + if (x < 0) { + if (s.charAt(i) == "-" && this.signum() == 0) + mi = true; + continue; + } + w = b * w + x; + if (++j >= cs) { + this.dMultiply(d); + this.dAddOffset(w, 0); + j = 0; + w = 0; + } + } + if (j > 0) { + this.dMultiply(Math.pow(b, j)); + this.dAddOffset(w, 0); + } + if (mi) + BigInteger.ZERO.subTo(this, this); + } + function bnpFromNumber(a, b, c) { + if ("number" == typeof b) { + if (a < 2) + this.fromInt(1); + else { + this.fromNumber(a, c); + if (!this.testBit(a - 1)) + this.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, this); + if (this.isEven()) + this.dAddOffset(1, 0); + while (!this.isProbablePrime(b)) { + this.dAddOffset(2, 0); + if (this.bitLength() > a) + this.subTo(BigInteger.ONE.shiftLeft(a - 1), this); + } + } + } else { + var x = new Array(), t2 = a & 7; + x.length = (a >> 3) + 1; + b.nextBytes(x); + if (t2 > 0) + x[0] &= (1 << t2) - 1; + else + x[0] = 0; + this.fromString(x, 256); + } + } + function bnToByteArray() { + var i = this.t, r = new Array(); + r[0] = this.s; + var p = this.DB - i * this.DB % 8, d, k = 0; + if (i-- > 0) { + if (p < this.DB && (d = this[i] >> p) != (this.s & this.DM) >> p) + r[k++] = d | this.s << this.DB - p; + while (i >= 0) { + if (p < 8) { + d = (this[i] & (1 << p) - 1) << 8 - p; + d |= this[--i] >> (p += this.DB - 8); + } else { + d = this[i] >> (p -= 8) & 255; + if (p <= 0) { + p += this.DB; + --i; + } + } + if ((d & 128) != 0) + d |= -256; + if (k == 0 && (this.s & 128) != (d & 128)) + ++k; + if (k > 0 || d != this.s) + r[k++] = d; + } + } + return r; + } + function bnEquals(a) { + return this.compareTo(a) == 0; + } + function bnMin(a) { + return this.compareTo(a) < 0 ? this : a; + } + function bnMax(a) { + return this.compareTo(a) > 0 ? this : a; + } + function bnpBitwiseTo(a, op, r) { + var i, f, m = Math.min(a.t, this.t); + for (i = 0; i < m; ++i) + r[i] = op(this[i], a[i]); + if (a.t < this.t) { + f = a.s & this.DM; + for (i = m; i < this.t; ++i) + r[i] = op(this[i], f); + r.t = this.t; + } else { + f = this.s & this.DM; + for (i = m; i < a.t; ++i) + r[i] = op(f, a[i]); + r.t = a.t; + } + r.s = op(this.s, a.s); + r.clamp(); + } + function op_and(x, y) { + return x & y; + } + function bnAnd(a) { + var r = nbi(); + this.bitwiseTo(a, op_and, r); + return r; + } + function op_or(x, y) { + return x | y; + } + function bnOr(a) { + var r = nbi(); + this.bitwiseTo(a, op_or, r); + return r; + } + function op_xor(x, y) { + return x ^ y; + } + function bnXor(a) { + var r = nbi(); + this.bitwiseTo(a, op_xor, r); + return r; + } + function op_andnot(x, y) { + return x & ~y; + } + function bnAndNot(a) { + var r = nbi(); + this.bitwiseTo(a, op_andnot, r); + return r; + } + function bnNot() { + var r = nbi(); + for (var i = 0; i < this.t; ++i) + r[i] = this.DM & ~this[i]; + r.t = this.t; + r.s = ~this.s; + return r; + } + function bnShiftLeft(n) { + var r = nbi(); + if (n < 0) + this.rShiftTo(-n, r); + else + this.lShiftTo(n, r); + return r; + } + function bnShiftRight(n) { + var r = nbi(); + if (n < 0) + this.lShiftTo(-n, r); + else + this.rShiftTo(n, r); + return r; + } + function lbit(x) { + if (x == 0) + return -1; + var r = 0; + if ((x & 65535) == 0) { + x >>= 16; + r += 16; + } + if ((x & 255) == 0) { + x >>= 8; + r += 8; + } + if ((x & 15) == 0) { + x >>= 4; + r += 4; + } + if ((x & 3) == 0) { + x >>= 2; + r += 2; + } + if ((x & 1) == 0) + ++r; + return r; + } + function bnGetLowestSetBit() { + for (var i = 0; i < this.t; ++i) + if (this[i] != 0) + return i * this.DB + lbit(this[i]); + if (this.s < 0) + return this.t * this.DB; + return -1; + } + function cbit(x) { + var r = 0; + while (x != 0) { + x &= x - 1; + ++r; + } + return r; + } + function bnBitCount() { + var r = 0, x = this.s & this.DM; + for (var i = 0; i < this.t; ++i) + r += cbit(this[i] ^ x); + return r; + } + function bnTestBit(n) { + var j = Math.floor(n / this.DB); + if (j >= this.t) + return this.s != 0; + return (this[j] & 1 << n % this.DB) != 0; + } + function bnpChangeBit(n, op) { + var r = BigInteger.ONE.shiftLeft(n); + this.bitwiseTo(r, op, r); + return r; + } + function bnSetBit(n) { + return this.changeBit(n, op_or); + } + function bnClearBit(n) { + return this.changeBit(n, op_andnot); + } + function bnFlipBit(n) { + return this.changeBit(n, op_xor); + } + function bnpAddTo(a, r) { + var i = 0, c = 0, m = Math.min(a.t, this.t); + while (i < m) { + c += this[i] + a[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + if (a.t < this.t) { + c += a.s; + while (i < this.t) { + c += this[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + c += this.s; + } else { + c += this.s; + while (i < a.t) { + c += a[i]; + r[i++] = c & this.DM; + c >>= this.DB; + } + c += a.s; + } + r.s = c < 0 ? -1 : 0; + if (c > 0) + r[i++] = c; + else if (c < -1) + r[i++] = this.DV + c; + r.t = i; + r.clamp(); + } + function bnAdd(a) { + var r = nbi(); + this.addTo(a, r); + return r; + } + function bnSubtract(a) { + var r = nbi(); + this.subTo(a, r); + return r; + } + function bnMultiply(a) { + var r = nbi(); + this.multiplyTo(a, r); + return r; + } + function bnSquare() { + var r = nbi(); + this.squareTo(r); + return r; + } + function bnDivide(a) { + var r = nbi(); + this.divRemTo(a, r, null); + return r; + } + function bnRemainder(a) { + var r = nbi(); + this.divRemTo(a, null, r); + return r; + } + function bnDivideAndRemainder(a) { + var q = nbi(), r = nbi(); + this.divRemTo(a, q, r); + return new Array(q, r); + } + function bnpDMultiply(n) { + this[this.t] = this.am(0, n - 1, this, 0, 0, this.t); + ++this.t; + this.clamp(); + } + function bnpDAddOffset(n, w) { + if (n == 0) + return; + while (this.t <= w) + this[this.t++] = 0; + this[w] += n; + while (this[w] >= this.DV) { + this[w] -= this.DV; + if (++w >= this.t) + this[this.t++] = 0; + ++this[w]; + } + } + function NullExp() { + } + function nNop(x) { + return x; + } + function nMulTo(x, y, r) { + x.multiplyTo(y, r); + } + function nSqrTo(x, r) { + x.squareTo(r); + } + NullExp.prototype.convert = nNop; + NullExp.prototype.revert = nNop; + NullExp.prototype.mulTo = nMulTo; + NullExp.prototype.sqrTo = nSqrTo; + function bnPow(e) { + return this.exp(e, new NullExp()); + } + function bnpMultiplyLowerTo(a, n, r) { + var i = Math.min(this.t + a.t, n); + r.s = 0; + r.t = i; + while (i > 0) + r[--i] = 0; + var j; + for (j = r.t - this.t; i < j; ++i) + r[i + this.t] = this.am(0, a[i], r, i, 0, this.t); + for (j = Math.min(a.t, n); i < j; ++i) + this.am(0, a[i], r, i, 0, n - i); + r.clamp(); + } + function bnpMultiplyUpperTo(a, n, r) { + --n; + var i = r.t = this.t + a.t - n; + r.s = 0; + while (--i >= 0) + r[i] = 0; + for (i = Math.max(n - this.t, 0); i < a.t; ++i) + r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n); + r.clamp(); + r.drShiftTo(1, r); + } + function Barrett(m) { + this.r2 = nbi(); + this.q3 = nbi(); + BigInteger.ONE.dlShiftTo(2 * m.t, this.r2); + this.mu = this.r2.divide(m); + this.m = m; + } + function barrettConvert(x) { + if (x.s < 0 || x.t > 2 * this.m.t) + return x.mod(this.m); + else if (x.compareTo(this.m) < 0) + return x; + else { + var r = nbi(); + x.copyTo(r); + this.reduce(r); + return r; + } + } + function barrettRevert(x) { + return x; + } + function barrettReduce(x) { + x.drShiftTo(this.m.t - 1, this.r2); + if (x.t > this.m.t + 1) { + x.t = this.m.t + 1; + x.clamp(); + } + this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3); + this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2); + while (x.compareTo(this.r2) < 0) + x.dAddOffset(1, this.m.t + 1); + x.subTo(this.r2, x); + while (x.compareTo(this.m) >= 0) + x.subTo(this.m, x); + } + function barrettSqrTo(x, r) { + x.squareTo(r); + this.reduce(r); + } + function barrettMulTo(x, y, r) { + x.multiplyTo(y, r); + this.reduce(r); + } + Barrett.prototype.convert = barrettConvert; + Barrett.prototype.revert = barrettRevert; + Barrett.prototype.reduce = barrettReduce; + Barrett.prototype.mulTo = barrettMulTo; + Barrett.prototype.sqrTo = barrettSqrTo; + function bnModPow(e, m) { + var i = e.bitLength(), k, r = nbv(1), z2; + if (i <= 0) + return r; + else if (i < 18) + k = 1; + else if (i < 48) + k = 3; + else if (i < 144) + k = 4; + else if (i < 768) + k = 5; + else + k = 6; + if (i < 8) + z2 = new Classic(m); + else if (m.isEven()) + z2 = new Barrett(m); + else + z2 = new Montgomery(m); + var g = new Array(), n = 3, k1 = k - 1, km = (1 << k) - 1; + g[1] = z2.convert(this); + if (k > 1) { + var g2 = nbi(); + z2.sqrTo(g[1], g2); + while (n <= km) { + g[n] = nbi(); + z2.mulTo(g2, g[n - 2], g[n]); + n += 2; + } + } + var j = e.t - 1, w, is1 = true, r2 = nbi(), t2; + i = nbits(e[j]) - 1; + while (j >= 0) { + if (i >= k1) + w = e[j] >> i - k1 & km; + else { + w = (e[j] & (1 << i + 1) - 1) << k1 - i; + if (j > 0) + w |= e[j - 1] >> this.DB + i - k1; + } + n = k; + while ((w & 1) == 0) { + w >>= 1; + --n; + } + if ((i -= n) < 0) { + i += this.DB; + --j; + } + if (is1) { + g[w].copyTo(r); + is1 = false; + } else { + while (n > 1) { + z2.sqrTo(r, r2); + z2.sqrTo(r2, r); + n -= 2; + } + if (n > 0) + z2.sqrTo(r, r2); + else { + t2 = r; + r = r2; + r2 = t2; + } + z2.mulTo(r2, g[w], r); + } + while (j >= 0 && (e[j] & 1 << i) == 0) { + z2.sqrTo(r, r2); + t2 = r; + r = r2; + r2 = t2; + if (--i < 0) { + i = this.DB - 1; + --j; + } + } + } + return z2.revert(r); + } + function bnGCD(a) { + var x = this.s < 0 ? this.negate() : this.clone(); + var y = a.s < 0 ? a.negate() : a.clone(); + if (x.compareTo(y) < 0) { + var t2 = x; + x = y; + y = t2; + } + var i = x.getLowestSetBit(), g = y.getLowestSetBit(); + if (g < 0) + return x; + if (i < g) + g = i; + if (g > 0) { + x.rShiftTo(g, x); + y.rShiftTo(g, y); + } + while (x.signum() > 0) { + if ((i = x.getLowestSetBit()) > 0) + x.rShiftTo(i, x); + if ((i = y.getLowestSetBit()) > 0) + y.rShiftTo(i, y); + if (x.compareTo(y) >= 0) { + x.subTo(y, x); + x.rShiftTo(1, x); + } else { + y.subTo(x, y); + y.rShiftTo(1, y); + } + } + if (g > 0) + y.lShiftTo(g, y); + return y; + } + function bnpModInt(n) { + if (n <= 0) + return 0; + var d = this.DV % n, r = this.s < 0 ? n - 1 : 0; + if (this.t > 0) + if (d == 0) + r = this[0] % n; + else + for (var i = this.t - 1; i >= 0; --i) + r = (d * r + this[i]) % n; + return r; + } + function bnModInverse(m) { + var ac = m.isEven(); + if (this.isEven() && ac || m.signum() == 0) + return BigInteger.ZERO; + var u = m.clone(), v = this.clone(); + var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1); + while (u.signum() != 0) { + while (u.isEven()) { + u.rShiftTo(1, u); + if (ac) { + if (!a.isEven() || !b.isEven()) { + a.addTo(this, a); + b.subTo(m, b); + } + a.rShiftTo(1, a); + } else if (!b.isEven()) + b.subTo(m, b); + b.rShiftTo(1, b); + } + while (v.isEven()) { + v.rShiftTo(1, v); + if (ac) { + if (!c.isEven() || !d.isEven()) { + c.addTo(this, c); + d.subTo(m, d); + } + c.rShiftTo(1, c); + } else if (!d.isEven()) + d.subTo(m, d); + d.rShiftTo(1, d); + } + if (u.compareTo(v) >= 0) { + u.subTo(v, u); + if (ac) + a.subTo(c, a); + b.subTo(d, b); + } else { + v.subTo(u, v); + if (ac) + c.subTo(a, c); + d.subTo(b, d); + } + } + if (v.compareTo(BigInteger.ONE) != 0) + return BigInteger.ZERO; + if (d.compareTo(m) >= 0) + return d.subtract(m); + if (d.signum() < 0) + d.addTo(m, d); + else + return d; + if (d.signum() < 0) + return d.add(m); + else + return d; + } + var lowprimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]; + var lplim = (1 << 26) / lowprimes[lowprimes.length - 1]; + function bnIsProbablePrime(t2) { + var i, x = this.abs(); + if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) { + for (i = 0; i < lowprimes.length; ++i) + if (x[0] == lowprimes[i]) + return true; + return false; + } + if (x.isEven()) + return false; + i = 1; + while (i < lowprimes.length) { + var m = lowprimes[i], j = i + 1; + while (j < lowprimes.length && m < lplim) + m *= lowprimes[j++]; + m = x.modInt(m); + while (i < j) + if (m % lowprimes[i++] == 0) + return false; + } + return x.millerRabin(t2); + } + function bnpMillerRabin(t2) { + var n1 = this.subtract(BigInteger.ONE); + var k = n1.getLowestSetBit(); + if (k <= 0) + return false; + var r = n1.shiftRight(k); + t2 = t2 + 1 >> 1; + if (t2 > lowprimes.length) + t2 = lowprimes.length; + var a = nbi(); + for (var i = 0; i < t2; ++i) { + a.fromInt(lowprimes[Math.floor(Math.random() * lowprimes.length)]); + var y = a.modPow(r, this); + if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) { + var j = 1; + while (j++ < k && y.compareTo(n1) != 0) { + y = y.modPowInt(2, this); + if (y.compareTo(BigInteger.ONE) == 0) + return false; + } + if (y.compareTo(n1) != 0) + return false; + } + } + return true; + } + BigInteger.prototype.chunkSize = bnpChunkSize; + BigInteger.prototype.toRadix = bnpToRadix; + BigInteger.prototype.fromRadix = bnpFromRadix; + BigInteger.prototype.fromNumber = bnpFromNumber; + BigInteger.prototype.bitwiseTo = bnpBitwiseTo; + BigInteger.prototype.changeBit = bnpChangeBit; + BigInteger.prototype.addTo = bnpAddTo; + BigInteger.prototype.dMultiply = bnpDMultiply; + BigInteger.prototype.dAddOffset = bnpDAddOffset; + BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo; + BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo; + BigInteger.prototype.modInt = bnpModInt; + BigInteger.prototype.millerRabin = bnpMillerRabin; + BigInteger.prototype.clone = bnClone; + BigInteger.prototype.intValue = bnIntValue; + BigInteger.prototype.byteValue = bnByteValue; + BigInteger.prototype.shortValue = bnShortValue; + BigInteger.prototype.signum = bnSigNum; + BigInteger.prototype.toByteArray = bnToByteArray; + BigInteger.prototype.equals = bnEquals; + BigInteger.prototype.min = bnMin; + BigInteger.prototype.max = bnMax; + BigInteger.prototype.and = bnAnd; + BigInteger.prototype.or = bnOr; + BigInteger.prototype.xor = bnXor; + BigInteger.prototype.andNot = bnAndNot; + BigInteger.prototype.not = bnNot; + BigInteger.prototype.shiftLeft = bnShiftLeft; + BigInteger.prototype.shiftRight = bnShiftRight; + BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit; + BigInteger.prototype.bitCount = bnBitCount; + BigInteger.prototype.testBit = bnTestBit; + BigInteger.prototype.setBit = bnSetBit; + BigInteger.prototype.clearBit = bnClearBit; + BigInteger.prototype.flipBit = bnFlipBit; + BigInteger.prototype.add = bnAdd; + BigInteger.prototype.subtract = bnSubtract; + BigInteger.prototype.multiply = bnMultiply; + BigInteger.prototype.divide = bnDivide; + BigInteger.prototype.remainder = bnRemainder; + BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder; + BigInteger.prototype.modPow = bnModPow; + BigInteger.prototype.modInverse = bnModInverse; + BigInteger.prototype.pow = bnPow; + BigInteger.prototype.gcd = bnGCD; + BigInteger.prototype.isProbablePrime = bnIsProbablePrime; + BigInteger.prototype.square = bnSquare; + BigInteger.prototype.Barrett = Barrett; + var rng_state; + var rng_pool; + var rng_pptr; + function rng_seed_int(x) { + rng_pool[rng_pptr++] ^= x & 255; + rng_pool[rng_pptr++] ^= x >> 8 & 255; + rng_pool[rng_pptr++] ^= x >> 16 & 255; + rng_pool[rng_pptr++] ^= x >> 24 & 255; + if (rng_pptr >= rng_psize) + rng_pptr -= rng_psize; + } + function rng_seed_time() { + rng_seed_int((/* @__PURE__ */ new Date()).getTime()); + } + if (rng_pool == null) { + rng_pool = new Array(); + rng_pptr = 0; + var t; + if (typeof window !== "undefined" && window.crypto) { + if (window.crypto.getRandomValues) { + var ua = new Uint8Array(32); + window.crypto.getRandomValues(ua); + for (t = 0; t < 32; ++t) + rng_pool[rng_pptr++] = ua[t]; + } else if (navigator.appName == "Netscape" && navigator.appVersion < "5") { + var z = window.crypto.random(32); + for (t = 0; t < z.length; ++t) + rng_pool[rng_pptr++] = z.charCodeAt(t) & 255; + } + } + while (rng_pptr < rng_psize) { + t = Math.floor(65536 * Math.random()); + rng_pool[rng_pptr++] = t >>> 8; + rng_pool[rng_pptr++] = t & 255; + } + rng_pptr = 0; + rng_seed_time(); + } + function rng_get_byte() { + if (rng_state == null) { + rng_seed_time(); + rng_state = prng_newstate(); + rng_state.init(rng_pool); + for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr) + rng_pool[rng_pptr] = 0; + rng_pptr = 0; + } + return rng_state.next(); + } + function rng_get_bytes(ba) { + var i; + for (i = 0; i < ba.length; ++i) + ba[i] = rng_get_byte(); + } + function SecureRandom() { + } + SecureRandom.prototype.nextBytes = rng_get_bytes; + function Arcfour() { + this.i = 0; + this.j = 0; + this.S = new Array(); + } + function ARC4init(key) { + var i, j, t2; + for (i = 0; i < 256; ++i) + this.S[i] = i; + j = 0; + for (i = 0; i < 256; ++i) { + j = j + this.S[i] + key[i % key.length] & 255; + t2 = this.S[i]; + this.S[i] = this.S[j]; + this.S[j] = t2; + } + this.i = 0; + this.j = 0; + } + function ARC4next() { + var t2; + this.i = this.i + 1 & 255; + this.j = this.j + this.S[this.i] & 255; + t2 = this.S[this.i]; + this.S[this.i] = this.S[this.j]; + this.S[this.j] = t2; + return this.S[t2 + this.S[this.i] & 255]; + } + Arcfour.prototype.init = ARC4init; + Arcfour.prototype.next = ARC4next; + function prng_newstate() { + return new Arcfour(); + } + var rng_psize = 256; + if (typeof exports !== "undefined") { + exports = module.exports = { + default: BigInteger, + BigInteger, + SecureRandom + }; + } else { + this.jsbn = { + BigInteger, + SecureRandom + }; + } + }).call(exports); + } +}); + +// ../testeranto/node_modules/sprintf-js/src/sprintf.js +var require_sprintf = __commonJS({ + "../testeranto/node_modules/sprintf-js/src/sprintf.js"(exports) { + init_cjs_shim(); + !function() { + "use strict"; + var re = { + not_string: /[^s]/, + not_bool: /[^t]/, + not_type: /[^T]/, + not_primitive: /[^v]/, + number: /[diefg]/, + numeric_arg: /[bcdiefguxX]/, + json: /[j]/, + not_json: /[^j]/, + text: /^[^\x25]+/, + modulo: /^\x25{2}/, + placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/, + key: /^([a-z_][a-z_\d]*)/i, + key_access: /^\.([a-z_][a-z_\d]*)/i, + index_access: /^\[(\d+)\]/, + sign: /^[+-]/ + }; + function sprintf(key) { + return sprintf_format(sprintf_parse(key), arguments); + } + function vsprintf(fmt, argv) { + return sprintf.apply(null, [fmt].concat(argv || [])); + } + function sprintf_format(parse_tree, argv) { + var cursor = 1, tree_length = parse_tree.length, arg, output = "", i, k, ph, pad, pad_character, pad_length, is_positive, sign; + for (i = 0; i < tree_length; i++) { + if (typeof parse_tree[i] === "string") { + output += parse_tree[i]; + } else if (typeof parse_tree[i] === "object") { + ph = parse_tree[i]; + if (ph.keys) { + arg = argv[cursor]; + for (k = 0; k < ph.keys.length; k++) { + if (arg == void 0) { + throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k - 1])); + } + arg = arg[ph.keys[k]]; + } + } else if (ph.param_no) { + arg = argv[ph.param_no]; + } else { + arg = argv[cursor++]; + } + if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) { + arg = arg(); + } + if (re.numeric_arg.test(ph.type) && (typeof arg !== "number" && isNaN(arg))) { + throw new TypeError(sprintf("[sprintf] expecting number but found %T", arg)); + } + if (re.number.test(ph.type)) { + is_positive = arg >= 0; + } + switch (ph.type) { + case "b": + arg = parseInt(arg, 10).toString(2); + break; + case "c": + arg = String.fromCharCode(parseInt(arg, 10)); + break; + case "d": + case "i": + arg = parseInt(arg, 10); + break; + case "j": + arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0); + break; + case "e": + arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential(); + break; + case "f": + arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg); + break; + case "g": + arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg); + break; + case "o": + arg = (parseInt(arg, 10) >>> 0).toString(8); + break; + case "s": + arg = String(arg); + arg = ph.precision ? arg.substring(0, ph.precision) : arg; + break; + case "t": + arg = String(!!arg); + arg = ph.precision ? arg.substring(0, ph.precision) : arg; + break; + case "T": + arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase(); + arg = ph.precision ? arg.substring(0, ph.precision) : arg; + break; + case "u": + arg = parseInt(arg, 10) >>> 0; + break; + case "v": + arg = arg.valueOf(); + arg = ph.precision ? arg.substring(0, ph.precision) : arg; + break; + case "x": + arg = (parseInt(arg, 10) >>> 0).toString(16); + break; + case "X": + arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase(); + break; + } + if (re.json.test(ph.type)) { + output += arg; + } else { + if (re.number.test(ph.type) && (!is_positive || ph.sign)) { + sign = is_positive ? "+" : "-"; + arg = arg.toString().replace(re.sign, ""); + } else { + sign = ""; + } + pad_character = ph.pad_char ? ph.pad_char === "0" ? "0" : ph.pad_char.charAt(1) : " "; + pad_length = ph.width - (sign + arg).length; + pad = ph.width ? pad_length > 0 ? pad_character.repeat(pad_length) : "" : ""; + output += ph.align ? sign + arg + pad : pad_character === "0" ? sign + pad + arg : pad + sign + arg; + } + } + } + return output; + } + var sprintf_cache = /* @__PURE__ */ Object.create(null); + function sprintf_parse(fmt) { + if (sprintf_cache[fmt]) { + return sprintf_cache[fmt]; + } + var _fmt = fmt, match, parse_tree = [], arg_names = 0; + while (_fmt) { + if ((match = re.text.exec(_fmt)) !== null) { + parse_tree.push(match[0]); + } else if ((match = re.modulo.exec(_fmt)) !== null) { + parse_tree.push("%"); + } else if ((match = re.placeholder.exec(_fmt)) !== null) { + if (match[2]) { + arg_names |= 1; + var field_list = [], replacement_field = match[2], field_match = []; + if ((field_match = re.key.exec(replacement_field)) !== null) { + field_list.push(field_match[1]); + while ((replacement_field = replacement_field.substring(field_match[0].length)) !== "") { + if ((field_match = re.key_access.exec(replacement_field)) !== null) { + field_list.push(field_match[1]); + } else if ((field_match = re.index_access.exec(replacement_field)) !== null) { + field_list.push(field_match[1]); + } else { + throw new SyntaxError("[sprintf] failed to parse named argument key"); + } + } + } else { + throw new SyntaxError("[sprintf] failed to parse named argument key"); + } + match[2] = field_list; + } else { + arg_names |= 2; + } + if (arg_names === 3) { + throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported"); + } + parse_tree.push( + { + placeholder: match[0], + param_no: match[1], + keys: match[2], + sign: match[3], + pad_char: match[4], + align: match[5], + width: match[6], + precision: match[7], + type: match[8] + } + ); + } else { + throw new SyntaxError("[sprintf] unexpected placeholder"); + } + _fmt = _fmt.substring(match[0].length); + } + return sprintf_cache[fmt] = parse_tree; + } + if (typeof exports !== "undefined") { + exports["sprintf"] = sprintf; + exports["vsprintf"] = vsprintf; + } + if (typeof window !== "undefined") { + window["sprintf"] = sprintf; + window["vsprintf"] = vsprintf; + if (typeof define === "function" && define["amd"]) { + define(function() { + return { + "sprintf": sprintf, + "vsprintf": vsprintf + }; + }); + } + } + }(); + } +}); + +// ../testeranto/node_modules/ip-address/dist/ipv4.js +var require_ipv4 = __commonJS({ + "../testeranto/node_modules/ip-address/dist/ipv4.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Address4 = void 0; + var common = __importStar2(require_common()); + var constants = __importStar2(require_constants3()); + var address_error_1 = require_address_error(); + var jsbn_1 = require_jsbn(); + var sprintf_js_1 = require_sprintf(); + var Address4 = class { + constructor(address) { + this.groups = constants.GROUPS; + this.parsedAddress = []; + this.parsedSubnet = ""; + this.subnet = "/32"; + this.subnetMask = 32; + this.v4 = true; + this.isCorrect = common.isCorrect(constants.BITS); + this.isInSubnet = common.isInSubnet; + this.address = address; + const subnet = constants.RE_SUBNET_STRING.exec(address); + if (subnet) { + this.parsedSubnet = subnet[0].replace("/", ""); + this.subnetMask = parseInt(this.parsedSubnet, 10); + this.subnet = `/${this.subnetMask}`; + if (this.subnetMask < 0 || this.subnetMask > constants.BITS) { + throw new address_error_1.AddressError("Invalid subnet mask."); + } + address = address.replace(constants.RE_SUBNET_STRING, ""); + } + this.addressMinusSuffix = address; + this.parsedAddress = this.parse(address); + } + static isValid(address) { + try { + new Address4(address); + return true; + } catch (e) { + return false; + } + } + /* + * Parses a v4 address + */ + parse(address) { + const groups = address.split("."); + if (!address.match(constants.RE_ADDRESS)) { + throw new address_error_1.AddressError("Invalid IPv4 address."); + } + return groups; + } + /** + * Returns the correct form of an address + * @memberof Address4 + * @instance + * @returns {String} + */ + correctForm() { + return this.parsedAddress.map((part) => parseInt(part, 10)).join("."); + } + /** + * Converts a hex string to an IPv4 address object + * @memberof Address4 + * @static + * @param {string} hex - a hex string to convert + * @returns {Address4} + */ + static fromHex(hex) { + const padded = hex.replace(/:/g, "").padStart(8, "0"); + const groups = []; + let i; + for (i = 0; i < 8; i += 2) { + const h = padded.slice(i, i + 2); + groups.push(parseInt(h, 16)); + } + return new Address4(groups.join(".")); + } + /** + * Converts an integer into a IPv4 address object + * @memberof Address4 + * @static + * @param {integer} integer - a number to convert + * @returns {Address4} + */ + static fromInteger(integer) { + return Address4.fromHex(integer.toString(16)); + } + /** + * Return an address from in-addr.arpa form + * @memberof Address4 + * @static + * @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address + * @returns {Adress4} + * @example + * var address = Address4.fromArpa(42.2.0.192.in-addr.arpa.) + * address.correctForm(); // '192.0.2.42' + */ + static fromArpa(arpaFormAddress) { + const leader = arpaFormAddress.replace(/(\.in-addr\.arpa)?\.$/, ""); + const address = leader.split(".").reverse().join("."); + return new Address4(address); + } + /** + * Converts an IPv4 address object to a hex string + * @memberof Address4 + * @instance + * @returns {String} + */ + toHex() { + return this.parsedAddress.map((part) => (0, sprintf_js_1.sprintf)("%02x", parseInt(part, 10))).join(":"); + } + /** + * Converts an IPv4 address object to an array of bytes + * @memberof Address4 + * @instance + * @returns {Array} + */ + toArray() { + return this.parsedAddress.map((part) => parseInt(part, 10)); + } + /** + * Converts an IPv4 address object to an IPv6 address group + * @memberof Address4 + * @instance + * @returns {String} + */ + toGroup6() { + const output = []; + let i; + for (i = 0; i < constants.GROUPS; i += 2) { + const hex = (0, sprintf_js_1.sprintf)("%02x%02x", parseInt(this.parsedAddress[i], 10), parseInt(this.parsedAddress[i + 1], 10)); + output.push((0, sprintf_js_1.sprintf)("%x", parseInt(hex, 16))); + } + return output.join(":"); + } + /** + * Returns the address as a BigInteger + * @memberof Address4 + * @instance + * @returns {BigInteger} + */ + bigInteger() { + return new jsbn_1.BigInteger(this.parsedAddress.map((n) => (0, sprintf_js_1.sprintf)("%02x", parseInt(n, 10))).join(""), 16); + } + /** + * Helper function getting start address. + * @memberof Address4 + * @instance + * @returns {BigInteger} + */ + _startAddress() { + return new jsbn_1.BigInteger(this.mask() + "0".repeat(constants.BITS - this.subnetMask), 2); + } + /** + * The first address in the range given by this address' subnet. + * Often referred to as the Network Address. + * @memberof Address4 + * @instance + * @returns {Address4} + */ + startAddress() { + return Address4.fromBigInteger(this._startAddress()); + } + /** + * The first host address in the range given by this address's subnet ie + * the first address after the Network Address + * @memberof Address4 + * @instance + * @returns {Address4} + */ + startAddressExclusive() { + const adjust = new jsbn_1.BigInteger("1"); + return Address4.fromBigInteger(this._startAddress().add(adjust)); + } + /** + * Helper function getting end address. + * @memberof Address4 + * @instance + * @returns {BigInteger} + */ + _endAddress() { + return new jsbn_1.BigInteger(this.mask() + "1".repeat(constants.BITS - this.subnetMask), 2); + } + /** + * The last address in the range given by this address' subnet + * Often referred to as the Broadcast + * @memberof Address4 + * @instance + * @returns {Address4} + */ + endAddress() { + return Address4.fromBigInteger(this._endAddress()); + } + /** + * The last host address in the range given by this address's subnet ie + * the last address prior to the Broadcast Address + * @memberof Address4 + * @instance + * @returns {Address4} + */ + endAddressExclusive() { + const adjust = new jsbn_1.BigInteger("1"); + return Address4.fromBigInteger(this._endAddress().subtract(adjust)); + } + /** + * Converts a BigInteger to a v4 address object + * @memberof Address4 + * @static + * @param {BigInteger} bigInteger - a BigInteger to convert + * @returns {Address4} + */ + static fromBigInteger(bigInteger) { + return Address4.fromInteger(parseInt(bigInteger.toString(), 10)); + } + /** + * Returns the first n bits of the address, defaulting to the + * subnet mask + * @memberof Address4 + * @instance + * @returns {String} + */ + mask(mask) { + if (mask === void 0) { + mask = this.subnetMask; + } + return this.getBitsBase2(0, mask); + } + /** + * Returns the bits in the given range as a base-2 string + * @memberof Address4 + * @instance + * @returns {string} + */ + getBitsBase2(start, end) { + return this.binaryZeroPad().slice(start, end); + } + /** + * Return the reversed ip6.arpa form of the address + * @memberof Address4 + * @param {Object} options + * @param {boolean} options.omitSuffix - omit the "in-addr.arpa" suffix + * @instance + * @returns {String} + */ + reverseForm(options) { + if (!options) { + options = {}; + } + const reversed = this.correctForm().split(".").reverse().join("."); + if (options.omitSuffix) { + return reversed; + } + return (0, sprintf_js_1.sprintf)("%s.in-addr.arpa.", reversed); + } + /** + * Returns true if the given address is a multicast address + * @memberof Address4 + * @instance + * @returns {boolean} + */ + isMulticast() { + return this.isInSubnet(new Address4("224.0.0.0/4")); + } + /** + * Returns a zero-padded base-2 string representation of the address + * @memberof Address4 + * @instance + * @returns {string} + */ + binaryZeroPad() { + return this.bigInteger().toString(2).padStart(constants.BITS, "0"); + } + /** + * Groups an IPv4 address for inclusion at the end of an IPv6 address + * @returns {String} + */ + groupForV6() { + const segments = this.parsedAddress; + return this.address.replace(constants.RE_ADDRESS, (0, sprintf_js_1.sprintf)('%s.%s', segments.slice(0, 2).join("."), segments.slice(2, 4).join("."))); + } + }; + exports.Address4 = Address4; + } +}); + +// ../testeranto/node_modules/ip-address/dist/v6/constants.js +var require_constants4 = __commonJS({ + "../testeranto/node_modules/ip-address/dist/v6/constants.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.RE_URL_WITH_PORT = exports.RE_URL = exports.RE_ZONE_STRING = exports.RE_SUBNET_STRING = exports.RE_BAD_ADDRESS = exports.RE_BAD_CHARACTERS = exports.TYPES = exports.SCOPES = exports.GROUPS = exports.BITS = void 0; + exports.BITS = 128; + exports.GROUPS = 8; + exports.SCOPES = { + 0: "Reserved", + 1: "Interface local", + 2: "Link local", + 4: "Admin local", + 5: "Site local", + 8: "Organization local", + 14: "Global", + 15: "Reserved" + }; + exports.TYPES = { + "ff01::1/128": "Multicast (All nodes on this interface)", + "ff01::2/128": "Multicast (All routers on this interface)", + "ff02::1/128": "Multicast (All nodes on this link)", + "ff02::2/128": "Multicast (All routers on this link)", + "ff05::2/128": "Multicast (All routers in this site)", + "ff02::5/128": "Multicast (OSPFv3 AllSPF routers)", + "ff02::6/128": "Multicast (OSPFv3 AllDR routers)", + "ff02::9/128": "Multicast (RIP routers)", + "ff02::a/128": "Multicast (EIGRP routers)", + "ff02::d/128": "Multicast (PIM routers)", + "ff02::16/128": "Multicast (MLDv2 reports)", + "ff01::fb/128": "Multicast (mDNSv6)", + "ff02::fb/128": "Multicast (mDNSv6)", + "ff05::fb/128": "Multicast (mDNSv6)", + "ff02::1:2/128": "Multicast (All DHCP servers and relay agents on this link)", + "ff05::1:2/128": "Multicast (All DHCP servers and relay agents in this site)", + "ff02::1:3/128": "Multicast (All DHCP servers on this link)", + "ff05::1:3/128": "Multicast (All DHCP servers in this site)", + "::/128": "Unspecified", + "::1/128": "Loopback", + "ff00::/8": "Multicast", + "fe80::/10": "Link-local unicast" + }; + exports.RE_BAD_CHARACTERS = /([^0-9a-f:/%])/gi; + exports.RE_BAD_ADDRESS = /([0-9a-f]{5,}|:{3,}|[^:]:$|^:[^:]|\/$)/gi; + exports.RE_SUBNET_STRING = /\/\d{1,3}(?=%|$)/; + exports.RE_ZONE_STRING = /%.*$/; + exports.RE_URL = new RegExp(/^\[{0,1}([0-9a-f:]+)\]{0,1}/); + exports.RE_URL_WITH_PORT = new RegExp(/\[([0-9a-f:]+)\]:([0-9]{1,5})/); + } +}); + +// ../testeranto/node_modules/ip-address/dist/v6/helpers.js +var require_helpers2 = __commonJS({ + "../testeranto/node_modules/ip-address/dist/v6/helpers.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.simpleGroup = exports.spanLeadingZeroes = exports.spanAll = exports.spanAllZeroes = void 0; + var sprintf_js_1 = require_sprintf(); + function spanAllZeroes(s) { + return s.replace(/(0+)/g, '$1'); + } + exports.spanAllZeroes = spanAllZeroes; + function spanAll(s, offset = 0) { + const letters = s.split(""); + return letters.map( + (n, i) => (0, sprintf_js_1.sprintf)('%s', n, i + offset, spanAllZeroes(n)) + // XXX Use #base-2 .value-0 instead? + ).join(""); + } + exports.spanAll = spanAll; + function spanLeadingZeroesSimple(group) { + return group.replace(/^(0+)/, '$1'); + } + function spanLeadingZeroes(address) { + const groups = address.split(":"); + return groups.map((g) => spanLeadingZeroesSimple(g)).join(":"); + } + exports.spanLeadingZeroes = spanLeadingZeroes; + function simpleGroup(addressString, offset = 0) { + const groups = addressString.split(":"); + return groups.map((g, i) => { + if (/group-v4/.test(g)) { + return g; + } + return (0, sprintf_js_1.sprintf)('%s', i + offset, spanLeadingZeroesSimple(g)); + }); + } + exports.simpleGroup = simpleGroup; + } +}); + +// ../testeranto/node_modules/ip-address/dist/v6/regular-expressions.js +var require_regular_expressions = __commonJS({ + "../testeranto/node_modules/ip-address/dist/v6/regular-expressions.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.possibleElisions = exports.simpleRegularExpression = exports.ADDRESS_BOUNDARY = exports.padGroup = exports.groupPossibilities = void 0; + var v6 = __importStar2(require_constants4()); + var sprintf_js_1 = require_sprintf(); + function groupPossibilities(possibilities) { + return (0, sprintf_js_1.sprintf)("(%s)", possibilities.join("|")); + } + exports.groupPossibilities = groupPossibilities; + function padGroup(group) { + if (group.length < 4) { + return (0, sprintf_js_1.sprintf)("0{0,%d}%s", 4 - group.length, group); + } + return group; + } + exports.padGroup = padGroup; + exports.ADDRESS_BOUNDARY = "[^A-Fa-f0-9:]"; + function simpleRegularExpression(groups) { + const zeroIndexes = []; + groups.forEach((group, i) => { + const groupInteger = parseInt(group, 16); + if (groupInteger === 0) { + zeroIndexes.push(i); + } + }); + const possibilities = zeroIndexes.map((zeroIndex) => groups.map((group, i) => { + if (i === zeroIndex) { + const elision = i === 0 || i === v6.GROUPS - 1 ? ":" : ""; + return groupPossibilities([padGroup(group), elision]); + } + return padGroup(group); + }).join(":")); + possibilities.push(groups.map(padGroup).join(":")); + return groupPossibilities(possibilities); + } + exports.simpleRegularExpression = simpleRegularExpression; + function possibleElisions(elidedGroups, moreLeft, moreRight) { + const left2 = moreLeft ? "" : ":"; + const right2 = moreRight ? "" : ":"; + const possibilities = []; + if (!moreLeft && !moreRight) { + possibilities.push("::"); + } + if (moreLeft && moreRight) { + possibilities.push(""); + } + if (moreRight && !moreLeft || !moreRight && moreLeft) { + possibilities.push(":"); + } + possibilities.push((0, sprintf_js_1.sprintf)("%s(:0{1,4}){1,%d}", left2, elidedGroups - 1)); + possibilities.push((0, sprintf_js_1.sprintf)("(0{1,4}:){1,%d}%s", elidedGroups - 1, right2)); + possibilities.push((0, sprintf_js_1.sprintf)("(0{1,4}:){%d}0{1,4}", elidedGroups - 1)); + for (let groups = 1; groups < elidedGroups - 1; groups++) { + for (let position = 1; position < elidedGroups - groups; position++) { + possibilities.push((0, sprintf_js_1.sprintf)("(0{1,4}:){%d}:(0{1,4}:){%d}0{1,4}", position, elidedGroups - position - groups - 1)); + } + } + return groupPossibilities(possibilities); + } + exports.possibleElisions = possibleElisions; + } +}); + +// ../testeranto/node_modules/ip-address/dist/ipv6.js +var require_ipv6 = __commonJS({ + "../testeranto/node_modules/ip-address/dist/ipv6.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Address6 = void 0; + var common = __importStar2(require_common()); + var constants4 = __importStar2(require_constants3()); + var constants6 = __importStar2(require_constants4()); + var helpers = __importStar2(require_helpers2()); + var ipv4_1 = require_ipv4(); + var regular_expressions_1 = require_regular_expressions(); + var address_error_1 = require_address_error(); + var jsbn_1 = require_jsbn(); + var sprintf_js_1 = require_sprintf(); + function assert3(condition) { + if (!condition) { + throw new Error("Assertion failed."); + } + } + function addCommas(number) { + const r = /(\d+)(\d{3})/; + while (r.test(number)) { + number = number.replace(r, "$1,$2"); + } + return number; + } + function spanLeadingZeroes4(n) { + n = n.replace(/^(0{1,})([1-9]+)$/, '$1$2'); + n = n.replace(/^(0{1,})(0)$/, '$1$2'); + return n; + } + function compact(address, slice) { + const s1 = []; + const s2 = []; + let i; + for (i = 0; i < address.length; i++) { + if (i < slice[0]) { + s1.push(address[i]); + } else if (i > slice[1]) { + s2.push(address[i]); + } + } + return s1.concat(["compact"]).concat(s2); + } + function paddedHex(octet) { + return (0, sprintf_js_1.sprintf)("%04x", parseInt(octet, 16)); + } + function unsignByte(b) { + return b & 255; + } + var Address6 = class { + constructor(address, optionalGroups) { + this.addressMinusSuffix = ""; + this.parsedSubnet = ""; + this.subnet = "/128"; + this.subnetMask = 128; + this.v4 = false; + this.zone = ""; + this.isInSubnet = common.isInSubnet; + this.isCorrect = common.isCorrect(constants6.BITS); + if (optionalGroups === void 0) { + this.groups = constants6.GROUPS; + } else { + this.groups = optionalGroups; + } + this.address = address; + const subnet = constants6.RE_SUBNET_STRING.exec(address); + if (subnet) { + this.parsedSubnet = subnet[0].replace("/", ""); + this.subnetMask = parseInt(this.parsedSubnet, 10); + this.subnet = `/${this.subnetMask}`; + if (Number.isNaN(this.subnetMask) || this.subnetMask < 0 || this.subnetMask > constants6.BITS) { + throw new address_error_1.AddressError("Invalid subnet mask."); + } + address = address.replace(constants6.RE_SUBNET_STRING, ""); + } else if (/\//.test(address)) { + throw new address_error_1.AddressError("Invalid subnet mask."); + } + const zone = constants6.RE_ZONE_STRING.exec(address); + if (zone) { + this.zone = zone[0]; + address = address.replace(constants6.RE_ZONE_STRING, ""); + } + this.addressMinusSuffix = address; + this.parsedAddress = this.parse(this.addressMinusSuffix); + } + static isValid(address) { + try { + new Address6(address); + return true; + } catch (e) { + return false; + } + } + /** + * Convert a BigInteger to a v6 address object + * @memberof Address6 + * @static + * @param {BigInteger} bigInteger - a BigInteger to convert + * @returns {Address6} + * @example + * var bigInteger = new BigInteger('1000000000000'); + * var address = Address6.fromBigInteger(bigInteger); + * address.correctForm(); // '::e8:d4a5:1000' + */ + static fromBigInteger(bigInteger) { + const hex = bigInteger.toString(16).padStart(32, "0"); + const groups = []; + let i; + for (i = 0; i < constants6.GROUPS; i++) { + groups.push(hex.slice(i * 4, (i + 1) * 4)); + } + return new Address6(groups.join(":")); + } + /** + * Convert a URL (with optional port number) to an address object + * @memberof Address6 + * @static + * @param {string} url - a URL with optional port number + * @example + * var addressAndPort = Address6.fromURL('http://[ffff::]:8080/foo/'); + * addressAndPort.address.correctForm(); // 'ffff::' + * addressAndPort.port; // 8080 + */ + static fromURL(url) { + let host; + let port = null; + let result; + if (url.indexOf("[") !== -1 && url.indexOf("]:") !== -1) { + result = constants6.RE_URL_WITH_PORT.exec(url); + if (result === null) { + return { + error: "failed to parse address with port", + address: null, + port: null + }; + } + host = result[1]; + port = result[2]; + } else if (url.indexOf("/") !== -1) { + url = url.replace(/^[a-z0-9]+:\/\//, ""); + result = constants6.RE_URL.exec(url); + if (result === null) { + return { + error: "failed to parse address from URL", + address: null, + port: null + }; + } + host = result[1]; + } else { + host = url; + } + if (port) { + port = parseInt(port, 10); + if (port < 0 || port > 65536) { + port = null; + } + } else { + port = null; + } + return { + address: new Address6(host), + port + }; + } + /** + * Create an IPv6-mapped address given an IPv4 address + * @memberof Address6 + * @static + * @param {string} address - An IPv4 address string + * @returns {Address6} + * @example + * var address = Address6.fromAddress4('192.168.0.1'); + * address.correctForm(); // '::ffff:c0a8:1' + * address.to4in6(); // '::ffff:192.168.0.1' + */ + static fromAddress4(address) { + const address4 = new ipv4_1.Address4(address); + const mask6 = constants6.BITS - (constants4.BITS - address4.subnetMask); + return new Address6(`::ffff:${address4.correctForm()}/${mask6}`); + } + /** + * Return an address from ip6.arpa form + * @memberof Address6 + * @static + * @param {string} arpaFormAddress - an 'ip6.arpa' form address + * @returns {Adress6} + * @example + * var address = Address6.fromArpa(e.f.f.f.3.c.2.6.f.f.f.e.6.6.8.e.1.0.6.7.9.4.e.c.0.0.0.0.1.0.0.2.ip6.arpa.) + * address.correctForm(); // '2001:0:ce49:7601:e866:efff:62c3:fffe' + */ + static fromArpa(arpaFormAddress) { + let address = arpaFormAddress.replace(/(\.ip6\.arpa)?\.$/, ""); + const semicolonAmount = 7; + if (address.length !== 63) { + throw new address_error_1.AddressError("Invalid 'ip6.arpa' form."); + } + const parts = address.split(".").reverse(); + for (let i = semicolonAmount; i > 0; i--) { + const insertIndex = i * 4; + parts.splice(insertIndex, 0, ":"); + } + address = parts.join(""); + return new Address6(address); + } + /** + * Return the Microsoft UNC transcription of the address + * @memberof Address6 + * @instance + * @returns {String} the Microsoft UNC transcription of the address + */ + microsoftTranscription() { + return (0, sprintf_js_1.sprintf)("%s.ipv6-literal.net", this.correctForm().replace(/:/g, "-")); + } + /** + * Return the first n bits of the address, defaulting to the subnet mask + * @memberof Address6 + * @instance + * @param {number} [mask=subnet] - the number of bits to mask + * @returns {String} the first n bits of the address as a string + */ + mask(mask = this.subnetMask) { + return this.getBitsBase2(0, mask); + } + /** + * Return the number of possible subnets of a given size in the address + * @memberof Address6 + * @instance + * @param {number} [size=128] - the subnet size + * @returns {String} + */ + // TODO: probably useful to have a numeric version of this too + possibleSubnets(subnetSize = 128) { + const availableBits = constants6.BITS - this.subnetMask; + const subnetBits = Math.abs(subnetSize - constants6.BITS); + const subnetPowers = availableBits - subnetBits; + if (subnetPowers < 0) { + return "0"; + } + return addCommas(new jsbn_1.BigInteger("2", 10).pow(subnetPowers).toString(10)); + } + /** + * Helper function getting start address. + * @memberof Address6 + * @instance + * @returns {BigInteger} + */ + _startAddress() { + return new jsbn_1.BigInteger(this.mask() + "0".repeat(constants6.BITS - this.subnetMask), 2); + } + /** + * The first address in the range given by this address' subnet + * Often referred to as the Network Address. + * @memberof Address6 + * @instance + * @returns {Address6} + */ + startAddress() { + return Address6.fromBigInteger(this._startAddress()); + } + /** + * The first host address in the range given by this address's subnet ie + * the first address after the Network Address + * @memberof Address6 + * @instance + * @returns {Address6} + */ + startAddressExclusive() { + const adjust = new jsbn_1.BigInteger("1"); + return Address6.fromBigInteger(this._startAddress().add(adjust)); + } + /** + * Helper function getting end address. + * @memberof Address6 + * @instance + * @returns {BigInteger} + */ + _endAddress() { + return new jsbn_1.BigInteger(this.mask() + "1".repeat(constants6.BITS - this.subnetMask), 2); + } + /** + * The last address in the range given by this address' subnet + * Often referred to as the Broadcast + * @memberof Address6 + * @instance + * @returns {Address6} + */ + endAddress() { + return Address6.fromBigInteger(this._endAddress()); + } + /** + * The last host address in the range given by this address's subnet ie + * the last address prior to the Broadcast Address + * @memberof Address6 + * @instance + * @returns {Address6} + */ + endAddressExclusive() { + const adjust = new jsbn_1.BigInteger("1"); + return Address6.fromBigInteger(this._endAddress().subtract(adjust)); + } + /** + * Return the scope of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + getScope() { + let scope = constants6.SCOPES[this.getBits(12, 16).intValue()]; + if (this.getType() === "Global unicast" && scope !== "Link local") { + scope = "Global"; + } + return scope || "Unknown"; + } + /** + * Return the type of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + getType() { + for (const subnet of Object.keys(constants6.TYPES)) { + if (this.isInSubnet(new Address6(subnet))) { + return constants6.TYPES[subnet]; + } + } + return "Global unicast"; + } + /** + * Return the bits in the given range as a BigInteger + * @memberof Address6 + * @instance + * @returns {BigInteger} + */ + getBits(start, end) { + return new jsbn_1.BigInteger(this.getBitsBase2(start, end), 2); + } + /** + * Return the bits in the given range as a base-2 string + * @memberof Address6 + * @instance + * @returns {String} + */ + getBitsBase2(start, end) { + return this.binaryZeroPad().slice(start, end); + } + /** + * Return the bits in the given range as a base-16 string + * @memberof Address6 + * @instance + * @returns {String} + */ + getBitsBase16(start, end) { + const length = end - start; + if (length % 4 !== 0) { + throw new Error("Length of bits to retrieve must be divisible by four"); + } + return this.getBits(start, end).toString(16).padStart(length / 4, "0"); + } + /** + * Return the bits that are set past the subnet mask length + * @memberof Address6 + * @instance + * @returns {String} + */ + getBitsPastSubnet() { + return this.getBitsBase2(this.subnetMask, constants6.BITS); + } + /** + * Return the reversed ip6.arpa form of the address + * @memberof Address6 + * @param {Object} options + * @param {boolean} options.omitSuffix - omit the "ip6.arpa" suffix + * @instance + * @returns {String} + */ + reverseForm(options) { + if (!options) { + options = {}; + } + const characters = Math.floor(this.subnetMask / 4); + const reversed = this.canonicalForm().replace(/:/g, "").split("").slice(0, characters).reverse().join("."); + if (characters > 0) { + if (options.omitSuffix) { + return reversed; + } + return (0, sprintf_js_1.sprintf)("%s.ip6.arpa.", reversed); + } + if (options.omitSuffix) { + return ""; + } + return "ip6.arpa."; + } + /** + * Return the correct form of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + correctForm() { + let i; + let groups = []; + let zeroCounter = 0; + const zeroes = []; + for (i = 0; i < this.parsedAddress.length; i++) { + const value = parseInt(this.parsedAddress[i], 16); + if (value === 0) { + zeroCounter++; + } + if (value !== 0 && zeroCounter > 0) { + if (zeroCounter > 1) { + zeroes.push([i - zeroCounter, i - 1]); + } + zeroCounter = 0; + } + } + if (zeroCounter > 1) { + zeroes.push([this.parsedAddress.length - zeroCounter, this.parsedAddress.length - 1]); + } + const zeroLengths = zeroes.map((n) => n[1] - n[0] + 1); + if (zeroes.length > 0) { + const index = zeroLengths.indexOf(Math.max(...zeroLengths)); + groups = compact(this.parsedAddress, zeroes[index]); + } else { + groups = this.parsedAddress; + } + for (i = 0; i < groups.length; i++) { + if (groups[i] !== "compact") { + groups[i] = parseInt(groups[i], 16).toString(16); + } + } + let correct = groups.join(":"); + correct = correct.replace(/^compact$/, "::"); + correct = correct.replace(/^compact|compact$/, ":"); + correct = correct.replace(/compact/, ""); + return correct; + } + /** + * Return a zero-padded base-2 string representation of the address + * @memberof Address6 + * @instance + * @returns {String} + * @example + * var address = new Address6('2001:4860:4001:803::1011'); + * address.binaryZeroPad(); + * // '0010000000000001010010000110000001000000000000010000100000000011 + * // 0000000000000000000000000000000000000000000000000001000000010001' + */ + binaryZeroPad() { + return this.bigInteger().toString(2).padStart(constants6.BITS, "0"); + } + // TODO: Improve the semantics of this helper function + parse4in6(address) { + const groups = address.split(":"); + const lastGroup = groups.slice(-1)[0]; + const address4 = lastGroup.match(constants4.RE_ADDRESS); + if (address4) { + this.parsedAddress4 = address4[0]; + this.address4 = new ipv4_1.Address4(this.parsedAddress4); + for (let i = 0; i < this.address4.groups; i++) { + if (/^0[0-9]+/.test(this.address4.parsedAddress[i])) { + throw new address_error_1.AddressError("IPv4 addresses can't have leading zeroes.", address.replace(constants4.RE_ADDRESS, this.address4.parsedAddress.map(spanLeadingZeroes4).join("."))); + } + } + this.v4 = true; + groups[groups.length - 1] = this.address4.toGroup6(); + address = groups.join(":"); + } + return address; + } + // TODO: Make private? + parse(address) { + address = this.parse4in6(address); + const badCharacters = address.match(constants6.RE_BAD_CHARACTERS); + if (badCharacters) { + throw new address_error_1.AddressError((0, sprintf_js_1.sprintf)("Bad character%s detected in address: %s", badCharacters.length > 1 ? "s" : "", badCharacters.join("")), address.replace(constants6.RE_BAD_CHARACTERS, '$1')); + } + const badAddress = address.match(constants6.RE_BAD_ADDRESS); + if (badAddress) { + throw new address_error_1.AddressError((0, sprintf_js_1.sprintf)("Address failed regex: %s", badAddress.join("")), address.replace(constants6.RE_BAD_ADDRESS, '$1')); + } + let groups = []; + const halves = address.split("::"); + if (halves.length === 2) { + let first = halves[0].split(":"); + let last = halves[1].split(":"); + if (first.length === 1 && first[0] === "") { + first = []; + } + if (last.length === 1 && last[0] === "") { + last = []; + } + const remaining = this.groups - (first.length + last.length); + if (!remaining) { + throw new address_error_1.AddressError("Error parsing groups"); + } + this.elidedGroups = remaining; + this.elisionBegin = first.length; + this.elisionEnd = first.length + this.elidedGroups; + groups = groups.concat(first); + for (let i = 0; i < remaining; i++) { + groups.push("0"); + } + groups = groups.concat(last); + } else if (halves.length === 1) { + groups = address.split(":"); + this.elidedGroups = 0; + } else { + throw new address_error_1.AddressError("Too many :: groups found"); + } + groups = groups.map((group) => (0, sprintf_js_1.sprintf)("%x", parseInt(group, 16))); + if (groups.length !== this.groups) { + throw new address_error_1.AddressError("Incorrect number of groups found"); + } + return groups; + } + /** + * Return the canonical form of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + canonicalForm() { + return this.parsedAddress.map(paddedHex).join(":"); + } + /** + * Return the decimal form of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + decimal() { + return this.parsedAddress.map((n) => (0, sprintf_js_1.sprintf)("%05d", parseInt(n, 16))).join(":"); + } + /** + * Return the address as a BigInteger + * @memberof Address6 + * @instance + * @returns {BigInteger} + */ + bigInteger() { + return new jsbn_1.BigInteger(this.parsedAddress.map(paddedHex).join(""), 16); + } + /** + * Return the last two groups of this address as an IPv4 address string + * @memberof Address6 + * @instance + * @returns {Address4} + * @example + * var address = new Address6('2001:4860:4001::1825:bf11'); + * address.to4().correctForm(); // '24.37.191.17' + */ + to4() { + const binary = this.binaryZeroPad().split(""); + return ipv4_1.Address4.fromHex(new jsbn_1.BigInteger(binary.slice(96, 128).join(""), 2).toString(16)); + } + /** + * Return the v4-in-v6 form of the address + * @memberof Address6 + * @instance + * @returns {String} + */ + to4in6() { + const address4 = this.to4(); + const address6 = new Address6(this.parsedAddress.slice(0, 6).join(":"), 6); + const correct = address6.correctForm(); + let infix = ""; + if (!/:$/.test(correct)) { + infix = ":"; + } + return correct + infix + address4.address; + } + /** + * Return an object containing the Teredo properties of the address + * @memberof Address6 + * @instance + * @returns {Object} + */ + inspectTeredo() { + const prefix = this.getBitsBase16(0, 32); + const udpPort = this.getBits(80, 96).xor(new jsbn_1.BigInteger("ffff", 16)).toString(); + const server4 = ipv4_1.Address4.fromHex(this.getBitsBase16(32, 64)); + const client4 = ipv4_1.Address4.fromHex(this.getBits(96, 128).xor(new jsbn_1.BigInteger("ffffffff", 16)).toString(16)); + const flags = this.getBits(64, 80); + const flagsBase2 = this.getBitsBase2(64, 80); + const coneNat = flags.testBit(15); + const reserved = flags.testBit(14); + const groupIndividual = flags.testBit(8); + const universalLocal = flags.testBit(9); + const nonce = new jsbn_1.BigInteger(flagsBase2.slice(2, 6) + flagsBase2.slice(8, 16), 2).toString(10); + return { + prefix: (0, sprintf_js_1.sprintf)("%s:%s", prefix.slice(0, 4), prefix.slice(4, 8)), + server4: server4.address, + client4: client4.address, + flags: flagsBase2, + coneNat, + microsoft: { + reserved, + universalLocal, + groupIndividual, + nonce + }, + udpPort + }; + } + /** + * Return an object containing the 6to4 properties of the address + * @memberof Address6 + * @instance + * @returns {Object} + */ + inspect6to4() { + const prefix = this.getBitsBase16(0, 16); + const gateway = ipv4_1.Address4.fromHex(this.getBitsBase16(16, 48)); + return { + prefix: (0, sprintf_js_1.sprintf)("%s", prefix.slice(0, 4)), + gateway: gateway.address + }; + } + /** + * Return a v6 6to4 address from a v6 v4inv6 address + * @memberof Address6 + * @instance + * @returns {Address6} + */ + to6to4() { + if (!this.is4()) { + return null; + } + const addr6to4 = [ + "2002", + this.getBitsBase16(96, 112), + this.getBitsBase16(112, 128), + "", + "/16" + ].join(":"); + return new Address6(addr6to4); + } + /** + * Return a byte array + * @memberof Address6 + * @instance + * @returns {Array} + */ + toByteArray() { + const byteArray = this.bigInteger().toByteArray(); + if (byteArray.length === 17 && byteArray[0] === 0) { + return byteArray.slice(1); + } + return byteArray; + } + /** + * Return an unsigned byte array + * @memberof Address6 + * @instance + * @returns {Array} + */ + toUnsignedByteArray() { + return this.toByteArray().map(unsignByte); + } + /** + * Convert a byte array to an Address6 object + * @memberof Address6 + * @static + * @returns {Address6} + */ + static fromByteArray(bytes) { + return this.fromUnsignedByteArray(bytes.map(unsignByte)); + } + /** + * Convert an unsigned byte array to an Address6 object + * @memberof Address6 + * @static + * @returns {Address6} + */ + static fromUnsignedByteArray(bytes) { + const BYTE_MAX = new jsbn_1.BigInteger("256", 10); + let result = new jsbn_1.BigInteger("0", 10); + let multiplier = new jsbn_1.BigInteger("1", 10); + for (let i = bytes.length - 1; i >= 0; i--) { + result = result.add(multiplier.multiply(new jsbn_1.BigInteger(bytes[i].toString(10), 10))); + multiplier = multiplier.multiply(BYTE_MAX); + } + return Address6.fromBigInteger(result); + } + /** + * Returns true if the address is in the canonical form, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + isCanonical() { + return this.addressMinusSuffix === this.canonicalForm(); + } + /** + * Returns true if the address is a link local address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + isLinkLocal() { + if (this.getBitsBase2(0, 64) === "1111111010000000000000000000000000000000000000000000000000000000") { + return true; + } + return false; + } + /** + * Returns true if the address is a multicast address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + isMulticast() { + return this.getType() === "Multicast"; + } + /** + * Returns true if the address is a v4-in-v6 address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + is4() { + return this.v4; + } + /** + * Returns true if the address is a Teredo address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + isTeredo() { + return this.isInSubnet(new Address6("2001::/32")); + } + /** + * Returns true if the address is a 6to4 address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + is6to4() { + return this.isInSubnet(new Address6("2002::/16")); + } + /** + * Returns true if the address is a loopback address, false otherwise + * @memberof Address6 + * @instance + * @returns {boolean} + */ + isLoopback() { + return this.getType() === "Loopback"; + } + // #endregion + // #region HTML + /** + * @returns {String} the address in link form with a default port of 80 + */ + href(optionalPort) { + if (optionalPort === void 0) { + optionalPort = ""; + } else { + optionalPort = (0, sprintf_js_1.sprintf)(":%s", optionalPort); + } + return (0, sprintf_js_1.sprintf)("http://[%s]%s/", this.correctForm(), optionalPort); + } + /** + * @returns {String} a link suitable for conveying the address via a URL hash + */ + link(options) { + if (!options) { + options = {}; + } + if (options.className === void 0) { + options.className = ""; + } + if (options.prefix === void 0) { + options.prefix = "/#address="; + } + if (options.v4 === void 0) { + options.v4 = false; + } + let formFunction = this.correctForm; + if (options.v4) { + formFunction = this.to4in6; + } + if (options.className) { + return (0, sprintf_js_1.sprintf)('%2$s', options.prefix, formFunction.call(this), options.className); + } + return (0, sprintf_js_1.sprintf)('%2$s', options.prefix, formFunction.call(this)); + } + /** + * Groups an address + * @returns {String} + */ + group() { + if (this.elidedGroups === 0) { + return helpers.simpleGroup(this.address).join(":"); + } + assert3(typeof this.elidedGroups === "number"); + assert3(typeof this.elisionBegin === "number"); + const output = []; + const [left2, right2] = this.address.split("::"); + if (left2.length) { + output.push(...helpers.simpleGroup(left2)); + } else { + output.push(""); + } + const classes = ["hover-group"]; + for (let i = this.elisionBegin; i < this.elisionBegin + this.elidedGroups; i++) { + classes.push((0, sprintf_js_1.sprintf)("group-%d", i)); + } + output.push((0, sprintf_js_1.sprintf)('', classes.join(" "))); + if (right2.length) { + output.push(...helpers.simpleGroup(right2, this.elisionEnd)); + } else { + output.push(""); + } + if (this.is4()) { + assert3(this.address4 instanceof ipv4_1.Address4); + output.pop(); + output.push(this.address4.groupForV6()); + } + return output.join(":"); + } + // #endregion + // #region Regular expressions + /** + * Generate a regular expression string that can be used to find or validate + * all variations of this address + * @memberof Address6 + * @instance + * @param {boolean} substringSearch + * @returns {string} + */ + regularExpressionString(substringSearch = false) { + let output = []; + const address6 = new Address6(this.correctForm()); + if (address6.elidedGroups === 0) { + output.push((0, regular_expressions_1.simpleRegularExpression)(address6.parsedAddress)); + } else if (address6.elidedGroups === constants6.GROUPS) { + output.push((0, regular_expressions_1.possibleElisions)(constants6.GROUPS)); + } else { + const halves = address6.address.split("::"); + if (halves[0].length) { + output.push((0, regular_expressions_1.simpleRegularExpression)(halves[0].split(":"))); + } + assert3(typeof address6.elidedGroups === "number"); + output.push((0, regular_expressions_1.possibleElisions)(address6.elidedGroups, halves[0].length !== 0, halves[1].length !== 0)); + if (halves[1].length) { + output.push((0, regular_expressions_1.simpleRegularExpression)(halves[1].split(":"))); + } + output = [output.join(":")]; + } + if (!substringSearch) { + output = [ + "(?=^|", + regular_expressions_1.ADDRESS_BOUNDARY, + "|[^\\w\\:])(", + ...output, + ")(?=[^\\w\\:]|", + regular_expressions_1.ADDRESS_BOUNDARY, + "|$)" + ]; + } + return output.join(""); + } + /** + * Generate a regular expression that can be used to find or validate all + * variations of this address. + * @memberof Address6 + * @instance + * @param {boolean} substringSearch + * @returns {RegExp} + */ + regularExpression(substringSearch = false) { + return new RegExp(this.regularExpressionString(substringSearch), "i"); + } + }; + exports.Address6 = Address6; + } +}); + +// ../testeranto/node_modules/ip-address/dist/ip-address.js +var require_ip_address = __commonJS({ + "../testeranto/node_modules/ip-address/dist/ip-address.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.v6 = exports.AddressError = exports.Address6 = exports.Address4 = void 0; + var ipv4_1 = require_ipv4(); + Object.defineProperty(exports, "Address4", { enumerable: true, get: function() { + return ipv4_1.Address4; + } }); + var ipv6_1 = require_ipv6(); + Object.defineProperty(exports, "Address6", { enumerable: true, get: function() { + return ipv6_1.Address6; + } }); + var address_error_1 = require_address_error(); + Object.defineProperty(exports, "AddressError", { enumerable: true, get: function() { + return address_error_1.AddressError; + } }); + var helpers = __importStar2(require_helpers2()); + exports.v6 = { helpers }; + } +}); + +// ../testeranto/node_modules/socks/build/common/helpers.js +var require_helpers3 = __commonJS({ + "../testeranto/node_modules/socks/build/common/helpers.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ipToBuffer = exports.int32ToIpv4 = exports.ipv4ToInt32 = exports.validateSocksClientChainOptions = exports.validateSocksClientOptions = void 0; + var util_1 = require_util(); + var constants_1 = require_constants2(); + var stream = __require("stream"); + var ip_address_1 = require_ip_address(); + var net = __require("net"); + function validateSocksClientOptions(options, acceptedCommands = ["connect", "bind", "associate"]) { + if (!constants_1.SocksCommand[options.command]) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommand, options); + } + if (acceptedCommands.indexOf(options.command) === -1) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommandForOperation, options); + } + if (!isValidSocksRemoteHost(options.destination)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsDestination, options); + } + if (!isValidSocksProxy(options.proxy)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxy, options); + } + validateCustomProxyAuth(options.proxy, options); + if (options.timeout && !isValidTimeoutValue(options.timeout)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsTimeout, options); + } + if (options.existing_socket && !(options.existing_socket instanceof stream.Duplex)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsExistingSocket, options); + } + } + exports.validateSocksClientOptions = validateSocksClientOptions; + function validateSocksClientChainOptions(options) { + if (options.command !== "connect") { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommandChain, options); + } + if (!isValidSocksRemoteHost(options.destination)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsDestination, options); + } + if (!(options.proxies && Array.isArray(options.proxies) && options.proxies.length >= 2)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxiesLength, options); + } + options.proxies.forEach((proxy) => { + if (!isValidSocksProxy(proxy)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsProxy, options); + } + validateCustomProxyAuth(proxy, options); + }); + if (options.timeout && !isValidTimeoutValue(options.timeout)) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsTimeout, options); + } + } + exports.validateSocksClientChainOptions = validateSocksClientChainOptions; + function validateCustomProxyAuth(proxy, options) { + if (proxy.custom_auth_method !== void 0) { + if (proxy.custom_auth_method < constants_1.SOCKS5_CUSTOM_AUTH_START || proxy.custom_auth_method > constants_1.SOCKS5_CUSTOM_AUTH_END) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthRange, options); + } + if (proxy.custom_auth_request_handler === void 0 || typeof proxy.custom_auth_request_handler !== "function") { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options); + } + if (proxy.custom_auth_response_size === void 0) { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options); + } + if (proxy.custom_auth_response_handler === void 0 || typeof proxy.custom_auth_response_handler !== "function") { + throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksClientOptionsCustomAuthOptions, options); + } + } + } + function isValidSocksRemoteHost(remoteHost) { + return remoteHost && typeof remoteHost.host === "string" && typeof remoteHost.port === "number" && remoteHost.port >= 0 && remoteHost.port <= 65535; + } + function isValidSocksProxy(proxy) { + return proxy && (typeof proxy.host === "string" || typeof proxy.ipaddress === "string") && typeof proxy.port === "number" && proxy.port >= 0 && proxy.port <= 65535 && (proxy.type === 4 || proxy.type === 5); + } + function isValidTimeoutValue(value) { + return typeof value === "number" && value > 0; + } + function ipv4ToInt32(ip) { + const address = new ip_address_1.Address4(ip); + return address.toArray().reduce((acc, part) => (acc << 8) + part, 0); + } + exports.ipv4ToInt32 = ipv4ToInt32; + function int32ToIpv4(int32) { + const octet1 = int32 >>> 24 & 255; + const octet2 = int32 >>> 16 & 255; + const octet3 = int32 >>> 8 & 255; + const octet4 = int32 & 255; + return [octet1, octet2, octet3, octet4].join("."); + } + exports.int32ToIpv4 = int32ToIpv4; + function ipToBuffer(ip) { + if (net.isIPv4(ip)) { + const address = new ip_address_1.Address4(ip); + return Buffer.from(address.toArray()); + } else if (net.isIPv6(ip)) { + const address = new ip_address_1.Address6(ip); + return Buffer.from(address.canonicalForm().split(":").map((segment) => segment.padStart(4, "0")).join(""), "hex"); + } else { + throw new Error("Invalid IP address format"); + } + } + exports.ipToBuffer = ipToBuffer; + } +}); + +// ../testeranto/node_modules/socks/build/common/receivebuffer.js +var require_receivebuffer = __commonJS({ + "../testeranto/node_modules/socks/build/common/receivebuffer.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ReceiveBuffer = void 0; + var ReceiveBuffer = class { + constructor(size = 4096) { + this.buffer = Buffer.allocUnsafe(size); + this.offset = 0; + this.originalSize = size; + } + get length() { + return this.offset; + } + append(data) { + if (!Buffer.isBuffer(data)) { + throw new Error("Attempted to append a non-buffer instance to ReceiveBuffer."); + } + if (this.offset + data.length >= this.buffer.length) { + const tmp = this.buffer; + this.buffer = Buffer.allocUnsafe(Math.max(this.buffer.length + this.originalSize, this.buffer.length + data.length)); + tmp.copy(this.buffer); + } + data.copy(this.buffer, this.offset); + return this.offset += data.length; + } + peek(length) { + if (length > this.offset) { + throw new Error("Attempted to read beyond the bounds of the managed internal data."); + } + return this.buffer.slice(0, length); + } + get(length) { + if (length > this.offset) { + throw new Error("Attempted to read beyond the bounds of the managed internal data."); + } + const value = Buffer.allocUnsafe(length); + this.buffer.slice(0, length).copy(value); + this.buffer.copyWithin(0, length, length + this.offset - length); + this.offset -= length; + return value; + } + }; + exports.ReceiveBuffer = ReceiveBuffer; + } +}); + +// ../testeranto/node_modules/socks/build/client/socksclient.js +var require_socksclient = __commonJS({ + "../testeranto/node_modules/socks/build/client/socksclient.js"(exports) { + "use strict"; + init_cjs_shim(); + var __awaiter2 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve5) { + resolve5(value); + }); + } + return new (P || (P = Promise))(function(resolve5, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } + } + function step(result) { + result.done ? resolve5(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SocksClientError = exports.SocksClient = void 0; + var events_1 = __require("events"); + var net = __require("net"); + var smart_buffer_1 = require_smartbuffer(); + var constants_1 = require_constants2(); + var helpers_1 = require_helpers3(); + var receivebuffer_1 = require_receivebuffer(); + var util_1 = require_util(); + Object.defineProperty(exports, "SocksClientError", { enumerable: true, get: function() { + return util_1.SocksClientError; + } }); + var ip_address_1 = require_ip_address(); + var SocksClient = class extends events_1.EventEmitter { + constructor(options) { + super(); + this.options = Object.assign({}, options); + (0, helpers_1.validateSocksClientOptions)(options); + this.setState(constants_1.SocksClientState.Created); + } + /** + * Creates a new SOCKS connection. + * + * Note: Supports callbacks and promises. Only supports the connect command. + * @param options { SocksClientOptions } Options. + * @param callback { Function } An optional callback function. + * @returns { Promise } + */ + static createConnection(options, callback) { + return new Promise((resolve5, reject) => { + try { + (0, helpers_1.validateSocksClientOptions)(options, ["connect"]); + } catch (err) { + if (typeof callback === "function") { + callback(err); + return resolve5(err); + } else { + return reject(err); + } + } + const client = new SocksClient(options); + client.connect(options.existing_socket); + client.once("established", (info) => { + client.removeAllListeners(); + if (typeof callback === "function") { + callback(null, info); + resolve5(info); + } else { + resolve5(info); + } + }); + client.once("error", (err) => { + client.removeAllListeners(); + if (typeof callback === "function") { + callback(err); + resolve5(err); + } else { + reject(err); + } + }); + }); + } + /** + * Creates a new SOCKS connection chain to a destination host through 2 or more SOCKS proxies. + * + * Note: Supports callbacks and promises. Only supports the connect method. + * Note: Implemented via createConnection() factory function. + * @param options { SocksClientChainOptions } Options + * @param callback { Function } An optional callback function. + * @returns { Promise } + */ + static createConnectionChain(options, callback) { + return new Promise((resolve5, reject) => __awaiter2(this, void 0, void 0, function* () { + try { + (0, helpers_1.validateSocksClientChainOptions)(options); + } catch (err) { + if (typeof callback === "function") { + callback(err); + return resolve5(err); + } else { + return reject(err); + } + } + if (options.randomizeChain) { + (0, util_1.shuffleArray)(options.proxies); + } + try { + let sock; + for (let i = 0; i < options.proxies.length; i++) { + const nextProxy = options.proxies[i]; + const nextDestination = i === options.proxies.length - 1 ? options.destination : { + host: options.proxies[i + 1].host || options.proxies[i + 1].ipaddress, + port: options.proxies[i + 1].port + }; + const result = yield SocksClient.createConnection({ + command: "connect", + proxy: nextProxy, + destination: nextDestination, + existing_socket: sock + }); + sock = sock || result.socket; + } + if (typeof callback === "function") { + callback(null, { socket: sock }); + resolve5({ socket: sock }); + } else { + resolve5({ socket: sock }); + } + } catch (err) { + if (typeof callback === "function") { + callback(err); + resolve5(err); + } else { + reject(err); + } + } + })); + } + /** + * Creates a SOCKS UDP Frame. + * @param options + */ + static createUDPFrame(options) { + const buff = new smart_buffer_1.SmartBuffer(); + buff.writeUInt16BE(0); + buff.writeUInt8(options.frameNumber || 0); + if (net.isIPv4(options.remoteHost.host)) { + buff.writeUInt8(constants_1.Socks5HostType.IPv4); + buff.writeUInt32BE((0, helpers_1.ipv4ToInt32)(options.remoteHost.host)); + } else if (net.isIPv6(options.remoteHost.host)) { + buff.writeUInt8(constants_1.Socks5HostType.IPv6); + buff.writeBuffer((0, helpers_1.ipToBuffer)(options.remoteHost.host)); + } else { + buff.writeUInt8(constants_1.Socks5HostType.Hostname); + buff.writeUInt8(Buffer.byteLength(options.remoteHost.host)); + buff.writeString(options.remoteHost.host); + } + buff.writeUInt16BE(options.remoteHost.port); + buff.writeBuffer(options.data); + return buff.toBuffer(); + } + /** + * Parses a SOCKS UDP frame. + * @param data + */ + static parseUDPFrame(data) { + const buff = smart_buffer_1.SmartBuffer.fromBuffer(data); + buff.readOffset = 2; + const frameNumber = buff.readUInt8(); + const hostType = buff.readUInt8(); + let remoteHost; + if (hostType === constants_1.Socks5HostType.IPv4) { + remoteHost = (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()); + } else if (hostType === constants_1.Socks5HostType.IPv6) { + remoteHost = ip_address_1.Address6.fromByteArray(Array.from(buff.readBuffer(16))).canonicalForm(); + } else { + remoteHost = buff.readString(buff.readUInt8()); + } + const remotePort = buff.readUInt16BE(); + return { + frameNumber, + remoteHost: { + host: remoteHost, + port: remotePort + }, + data: buff.readBuffer() + }; + } + /** + * Internal state setter. If the SocksClient is in an error state, it cannot be changed to a non error state. + */ + setState(newState) { + if (this.state !== constants_1.SocksClientState.Error) { + this.state = newState; + } + } + /** + * Starts the connection establishment to the proxy and destination. + * @param existingSocket Connected socket to use instead of creating a new one (internal use). + */ + connect(existingSocket) { + this.onDataReceived = (data) => this.onDataReceivedHandler(data); + this.onClose = () => this.onCloseHandler(); + this.onError = (err) => this.onErrorHandler(err); + this.onConnect = () => this.onConnectHandler(); + const timer2 = setTimeout(() => this.onEstablishedTimeout(), this.options.timeout || constants_1.DEFAULT_TIMEOUT); + if (timer2.unref && typeof timer2.unref === "function") { + timer2.unref(); + } + if (existingSocket) { + this.socket = existingSocket; + } else { + this.socket = new net.Socket(); + } + this.socket.once("close", this.onClose); + this.socket.once("error", this.onError); + this.socket.once("connect", this.onConnect); + this.socket.on("data", this.onDataReceived); + this.setState(constants_1.SocksClientState.Connecting); + this.receiveBuffer = new receivebuffer_1.ReceiveBuffer(); + if (existingSocket) { + this.socket.emit("connect"); + } else { + this.socket.connect(this.getSocketOptions()); + if (this.options.set_tcp_nodelay !== void 0 && this.options.set_tcp_nodelay !== null) { + this.socket.setNoDelay(!!this.options.set_tcp_nodelay); + } + } + this.prependOnceListener("established", (info) => { + setImmediate(() => { + if (this.receiveBuffer.length > 0) { + const excessData = this.receiveBuffer.get(this.receiveBuffer.length); + info.socket.emit("data", excessData); + } + info.socket.resume(); + }); + }); + } + // Socket options (defaults host/port to options.proxy.host/options.proxy.port) + getSocketOptions() { + return Object.assign(Object.assign({}, this.options.socket_options), { host: this.options.proxy.host || this.options.proxy.ipaddress, port: this.options.proxy.port }); + } + /** + * Handles internal Socks timeout callback. + * Note: If the Socks client is not BoundWaitingForConnection or Established, the connection will be closed. + */ + onEstablishedTimeout() { + if (this.state !== constants_1.SocksClientState.Established && this.state !== constants_1.SocksClientState.BoundWaitingForConnection) { + this.closeSocket(constants_1.ERRORS.ProxyConnectionTimedOut); + } + } + /** + * Handles Socket connect event. + */ + onConnectHandler() { + this.setState(constants_1.SocksClientState.Connected); + if (this.options.proxy.type === 4) { + this.sendSocks4InitialHandshake(); + } else { + this.sendSocks5InitialHandshake(); + } + this.setState(constants_1.SocksClientState.SentInitialHandshake); + } + /** + * Handles Socket data event. + * @param data + */ + onDataReceivedHandler(data) { + this.receiveBuffer.append(data); + this.processData(); + } + /** + * Handles processing of the data we have received. + */ + processData() { + while (this.state !== constants_1.SocksClientState.Established && this.state !== constants_1.SocksClientState.Error && this.receiveBuffer.length >= this.nextRequiredPacketBufferSize) { + if (this.state === constants_1.SocksClientState.SentInitialHandshake) { + if (this.options.proxy.type === 4) { + this.handleSocks4FinalHandshakeResponse(); + } else { + this.handleInitialSocks5HandshakeResponse(); + } + } else if (this.state === constants_1.SocksClientState.SentAuthentication) { + this.handleInitialSocks5AuthenticationHandshakeResponse(); + } else if (this.state === constants_1.SocksClientState.SentFinalHandshake) { + this.handleSocks5FinalHandshakeResponse(); + } else if (this.state === constants_1.SocksClientState.BoundWaitingForConnection) { + if (this.options.proxy.type === 4) { + this.handleSocks4IncomingConnectionResponse(); + } else { + this.handleSocks5IncomingConnectionResponse(); + } + } else { + this.closeSocket(constants_1.ERRORS.InternalError); + break; + } + } + } + /** + * Handles Socket close event. + * @param had_error + */ + onCloseHandler() { + this.closeSocket(constants_1.ERRORS.SocketClosed); + } + /** + * Handles Socket error event. + * @param err + */ + onErrorHandler(err) { + this.closeSocket(err.message); + } + /** + * Removes internal event listeners on the underlying Socket. + */ + removeInternalSocketHandlers() { + this.socket.pause(); + this.socket.removeListener("data", this.onDataReceived); + this.socket.removeListener("close", this.onClose); + this.socket.removeListener("error", this.onError); + this.socket.removeListener("connect", this.onConnect); + } + /** + * Closes and destroys the underlying Socket. Emits an error event. + * @param err { String } An error string to include in error event. + */ + closeSocket(err) { + if (this.state !== constants_1.SocksClientState.Error) { + this.setState(constants_1.SocksClientState.Error); + this.socket.destroy(); + this.removeInternalSocketHandlers(); + this.emit("error", new util_1.SocksClientError(err, this.options)); + } + } + /** + * Sends initial Socks v4 handshake request. + */ + sendSocks4InitialHandshake() { + const userId = this.options.proxy.userId || ""; + const buff = new smart_buffer_1.SmartBuffer(); + buff.writeUInt8(4); + buff.writeUInt8(constants_1.SocksCommand[this.options.command]); + buff.writeUInt16BE(this.options.destination.port); + if (net.isIPv4(this.options.destination.host)) { + buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host)); + buff.writeStringNT(userId); + } else { + buff.writeUInt8(0); + buff.writeUInt8(0); + buff.writeUInt8(0); + buff.writeUInt8(1); + buff.writeStringNT(userId); + buff.writeStringNT(this.options.destination.host); + } + this.nextRequiredPacketBufferSize = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks4Response; + this.socket.write(buff.toBuffer()); + } + /** + * Handles Socks v4 handshake response. + * @param data + */ + handleSocks4FinalHandshakeResponse() { + const data = this.receiveBuffer.get(8); + if (data[1] !== constants_1.Socks4Response.Granted) { + this.closeSocket(`${constants_1.ERRORS.Socks4ProxyRejectedConnection} - (${constants_1.Socks4Response[data[1]]})`); + } else { + if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.bind) { + const buff = smart_buffer_1.SmartBuffer.fromBuffer(data); + buff.readOffset = 2; + const remoteHost = { + port: buff.readUInt16BE(), + host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()) + }; + if (remoteHost.host === "0.0.0.0") { + remoteHost.host = this.options.proxy.ipaddress; + } + this.setState(constants_1.SocksClientState.BoundWaitingForConnection); + this.emit("bound", { remoteHost, socket: this.socket }); + } else { + this.setState(constants_1.SocksClientState.Established); + this.removeInternalSocketHandlers(); + this.emit("established", { socket: this.socket }); + } + } + } + /** + * Handles Socks v4 incoming connection request (BIND) + * @param data + */ + handleSocks4IncomingConnectionResponse() { + const data = this.receiveBuffer.get(8); + if (data[1] !== constants_1.Socks4Response.Granted) { + this.closeSocket(`${constants_1.ERRORS.Socks4ProxyRejectedIncomingBoundConnection} - (${constants_1.Socks4Response[data[1]]})`); + } else { + const buff = smart_buffer_1.SmartBuffer.fromBuffer(data); + buff.readOffset = 2; + const remoteHost = { + port: buff.readUInt16BE(), + host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()) + }; + this.setState(constants_1.SocksClientState.Established); + this.removeInternalSocketHandlers(); + this.emit("established", { remoteHost, socket: this.socket }); + } + } + /** + * Sends initial Socks v5 handshake request. + */ + sendSocks5InitialHandshake() { + const buff = new smart_buffer_1.SmartBuffer(); + const supportedAuthMethods = [constants_1.Socks5Auth.NoAuth]; + if (this.options.proxy.userId || this.options.proxy.password) { + supportedAuthMethods.push(constants_1.Socks5Auth.UserPass); + } + if (this.options.proxy.custom_auth_method !== void 0) { + supportedAuthMethods.push(this.options.proxy.custom_auth_method); + } + buff.writeUInt8(5); + buff.writeUInt8(supportedAuthMethods.length); + for (const authMethod of supportedAuthMethods) { + buff.writeUInt8(authMethod); + } + this.nextRequiredPacketBufferSize = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5InitialHandshakeResponse; + this.socket.write(buff.toBuffer()); + this.setState(constants_1.SocksClientState.SentInitialHandshake); + } + /** + * Handles initial Socks v5 handshake response. + * @param data + */ + handleInitialSocks5HandshakeResponse() { + const data = this.receiveBuffer.get(2); + if (data[0] !== 5) { + this.closeSocket(constants_1.ERRORS.InvalidSocks5IntiailHandshakeSocksVersion); + } else if (data[1] === constants_1.SOCKS5_NO_ACCEPTABLE_AUTH) { + this.closeSocket(constants_1.ERRORS.InvalidSocks5InitialHandshakeNoAcceptedAuthType); + } else { + if (data[1] === constants_1.Socks5Auth.NoAuth) { + this.socks5ChosenAuthType = constants_1.Socks5Auth.NoAuth; + this.sendSocks5CommandRequest(); + } else if (data[1] === constants_1.Socks5Auth.UserPass) { + this.socks5ChosenAuthType = constants_1.Socks5Auth.UserPass; + this.sendSocks5UserPassAuthentication(); + } else if (data[1] === this.options.proxy.custom_auth_method) { + this.socks5ChosenAuthType = this.options.proxy.custom_auth_method; + this.sendSocks5CustomAuthentication(); + } else { + this.closeSocket(constants_1.ERRORS.InvalidSocks5InitialHandshakeUnknownAuthType); + } + } + } + /** + * Sends Socks v5 user & password auth handshake. + * + * Note: No auth and user/pass are currently supported. + */ + sendSocks5UserPassAuthentication() { + const userId = this.options.proxy.userId || ""; + const password = this.options.proxy.password || ""; + const buff = new smart_buffer_1.SmartBuffer(); + buff.writeUInt8(1); + buff.writeUInt8(Buffer.byteLength(userId)); + buff.writeString(userId); + buff.writeUInt8(Buffer.byteLength(password)); + buff.writeString(password); + this.nextRequiredPacketBufferSize = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5UserPassAuthenticationResponse; + this.socket.write(buff.toBuffer()); + this.setState(constants_1.SocksClientState.SentAuthentication); + } + sendSocks5CustomAuthentication() { + return __awaiter2(this, void 0, void 0, function* () { + this.nextRequiredPacketBufferSize = this.options.proxy.custom_auth_response_size; + this.socket.write(yield this.options.proxy.custom_auth_request_handler()); + this.setState(constants_1.SocksClientState.SentAuthentication); + }); + } + handleSocks5CustomAuthHandshakeResponse(data) { + return __awaiter2(this, void 0, void 0, function* () { + return yield this.options.proxy.custom_auth_response_handler(data); + }); + } + handleSocks5AuthenticationNoAuthHandshakeResponse(data) { + return __awaiter2(this, void 0, void 0, function* () { + return data[1] === 0; + }); + } + handleSocks5AuthenticationUserPassHandshakeResponse(data) { + return __awaiter2(this, void 0, void 0, function* () { + return data[1] === 0; + }); + } + /** + * Handles Socks v5 auth handshake response. + * @param data + */ + handleInitialSocks5AuthenticationHandshakeResponse() { + return __awaiter2(this, void 0, void 0, function* () { + this.setState(constants_1.SocksClientState.ReceivedAuthenticationResponse); + let authResult = false; + if (this.socks5ChosenAuthType === constants_1.Socks5Auth.NoAuth) { + authResult = yield this.handleSocks5AuthenticationNoAuthHandshakeResponse(this.receiveBuffer.get(2)); + } else if (this.socks5ChosenAuthType === constants_1.Socks5Auth.UserPass) { + authResult = yield this.handleSocks5AuthenticationUserPassHandshakeResponse(this.receiveBuffer.get(2)); + } else if (this.socks5ChosenAuthType === this.options.proxy.custom_auth_method) { + authResult = yield this.handleSocks5CustomAuthHandshakeResponse(this.receiveBuffer.get(this.options.proxy.custom_auth_response_size)); + } + if (!authResult) { + this.closeSocket(constants_1.ERRORS.Socks5AuthenticationFailed); + } else { + this.sendSocks5CommandRequest(); + } + }); + } + /** + * Sends Socks v5 final handshake request. + */ + sendSocks5CommandRequest() { + const buff = new smart_buffer_1.SmartBuffer(); + buff.writeUInt8(5); + buff.writeUInt8(constants_1.SocksCommand[this.options.command]); + buff.writeUInt8(0); + if (net.isIPv4(this.options.destination.host)) { + buff.writeUInt8(constants_1.Socks5HostType.IPv4); + buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host)); + } else if (net.isIPv6(this.options.destination.host)) { + buff.writeUInt8(constants_1.Socks5HostType.IPv6); + buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host)); + } else { + buff.writeUInt8(constants_1.Socks5HostType.Hostname); + buff.writeUInt8(this.options.destination.host.length); + buff.writeString(this.options.destination.host); + } + buff.writeUInt16BE(this.options.destination.port); + this.nextRequiredPacketBufferSize = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHeader; + this.socket.write(buff.toBuffer()); + this.setState(constants_1.SocksClientState.SentFinalHandshake); + } + /** + * Handles Socks v5 final handshake response. + * @param data + */ + handleSocks5FinalHandshakeResponse() { + const header = this.receiveBuffer.peek(5); + if (header[0] !== 5 || header[1] !== constants_1.Socks5Response.Granted) { + this.closeSocket(`${constants_1.ERRORS.InvalidSocks5FinalHandshakeRejected} - ${constants_1.Socks5Response[header[1]]}`); + } else { + const addressType = header[3]; + let remoteHost; + let buff; + if (addressType === constants_1.Socks5HostType.IPv4) { + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv4; + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4)); + remoteHost = { + host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()), + port: buff.readUInt16BE() + }; + if (remoteHost.host === "0.0.0.0") { + remoteHost.host = this.options.proxy.ipaddress; + } + } else if (addressType === constants_1.Socks5HostType.Hostname) { + const hostLength = header[4]; + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHostname(hostLength); + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(5)); + remoteHost = { + host: buff.readString(hostLength), + port: buff.readUInt16BE() + }; + } else if (addressType === constants_1.Socks5HostType.IPv6) { + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv6; + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4)); + remoteHost = { + host: ip_address_1.Address6.fromByteArray(Array.from(buff.readBuffer(16))).canonicalForm(), + port: buff.readUInt16BE() + }; + } + this.setState(constants_1.SocksClientState.ReceivedFinalResponse); + if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.connect) { + this.setState(constants_1.SocksClientState.Established); + this.removeInternalSocketHandlers(); + this.emit("established", { remoteHost, socket: this.socket }); + } else if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.bind) { + this.setState(constants_1.SocksClientState.BoundWaitingForConnection); + this.nextRequiredPacketBufferSize = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHeader; + this.emit("bound", { remoteHost, socket: this.socket }); + } else if (constants_1.SocksCommand[this.options.command] === constants_1.SocksCommand.associate) { + this.setState(constants_1.SocksClientState.Established); + this.removeInternalSocketHandlers(); + this.emit("established", { + remoteHost, + socket: this.socket + }); + } + } + } + /** + * Handles Socks v5 incoming connection request (BIND). + */ + handleSocks5IncomingConnectionResponse() { + const header = this.receiveBuffer.peek(5); + if (header[0] !== 5 || header[1] !== constants_1.Socks5Response.Granted) { + this.closeSocket(`${constants_1.ERRORS.Socks5ProxyRejectedIncomingBoundConnection} - ${constants_1.Socks5Response[header[1]]}`); + } else { + const addressType = header[3]; + let remoteHost; + let buff; + if (addressType === constants_1.Socks5HostType.IPv4) { + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv4; + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4)); + remoteHost = { + host: (0, helpers_1.int32ToIpv4)(buff.readUInt32BE()), + port: buff.readUInt16BE() + }; + if (remoteHost.host === "0.0.0.0") { + remoteHost.host = this.options.proxy.ipaddress; + } + } else if (addressType === constants_1.Socks5HostType.Hostname) { + const hostLength = header[4]; + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseHostname(hostLength); + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(5)); + remoteHost = { + host: buff.readString(hostLength), + port: buff.readUInt16BE() + }; + } else if (addressType === constants_1.Socks5HostType.IPv6) { + const dataNeeded = constants_1.SOCKS_INCOMING_PACKET_SIZES.Socks5ResponseIPv6; + if (this.receiveBuffer.length < dataNeeded) { + this.nextRequiredPacketBufferSize = dataNeeded; + return; + } + buff = smart_buffer_1.SmartBuffer.fromBuffer(this.receiveBuffer.get(dataNeeded).slice(4)); + remoteHost = { + host: ip_address_1.Address6.fromByteArray(Array.from(buff.readBuffer(16))).canonicalForm(), + port: buff.readUInt16BE() + }; + } + this.setState(constants_1.SocksClientState.Established); + this.removeInternalSocketHandlers(); + this.emit("established", { remoteHost, socket: this.socket }); + } + } + get socksClientOptions() { + return Object.assign({}, this.options); + } + }; + exports.SocksClient = SocksClient; + } +}); + +// ../testeranto/node_modules/socks/build/index.js +var require_build = __commonJS({ + "../testeranto/node_modules/socks/build/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __exportStar2 = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) + __createBinding2(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + __exportStar2(require_socksclient(), exports); + } +}); + +// ../testeranto/node_modules/socks-proxy-agent/dist/index.js +var require_dist4 = __commonJS({ + "../testeranto/node_modules/socks-proxy-agent/dist/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SocksProxyAgent = void 0; + var socks_1 = require_build(); + var agent_base_1 = require_dist(); + var debug_1 = __importDefault2(require_src()); + var dns = __importStar2(__require("dns")); + var tls = __importStar2(__require("tls")); + var url_1 = __require("url"); + var debug5 = (0, debug_1.default)("socks-proxy-agent"); + function parseSocksURL(url) { + let lookup = false; + let type = 5; + const host = url.hostname; + const port = parseInt(url.port, 10) || 1080; + switch (url.protocol.replace(":", "")) { + case "socks4": + lookup = true; + type = 4; + break; + case "socks4a": + type = 4; + break; + case "socks5": + lookup = true; + type = 5; + break; + case "socks": + type = 5; + break; + case "socks5h": + type = 5; + break; + default: + throw new TypeError(`A "socks" protocol must be specified! Got: ${String(url.protocol)}`); + } + const proxy = { + host, + port, + type + }; + if (url.username) { + Object.defineProperty(proxy, "userId", { + value: decodeURIComponent(url.username), + enumerable: false + }); + } + if (url.password != null) { + Object.defineProperty(proxy, "password", { + value: decodeURIComponent(url.password), + enumerable: false + }); + } + return { lookup, proxy }; + } + var SocksProxyAgent = class extends agent_base_1.Agent { + constructor(uri, opts) { + super(opts); + const url = typeof uri === "string" ? new url_1.URL(uri) : uri; + const { proxy, lookup } = parseSocksURL(url); + this.shouldLookup = lookup; + this.proxy = proxy; + this.timeout = opts?.timeout ?? null; + this.socketOptions = opts?.socketOptions ?? null; + } + /** + * Initiates a SOCKS connection to the specified SOCKS proxy server, + * which in turn connects to the specified remote host and port. + */ + async connect(req, opts) { + const { shouldLookup, proxy, timeout: timeout2 } = this; + if (!opts.host) { + throw new Error("No `host` defined!"); + } + let { host } = opts; + const { port, lookup: lookupFn = dns.lookup } = opts; + if (shouldLookup) { + host = await new Promise((resolve5, reject) => { + lookupFn(host, {}, (err, res) => { + if (err) { + reject(err); + } else { + resolve5(res); + } + }); + }); + } + const socksOpts = { + proxy, + destination: { + host, + port: typeof port === "number" ? port : parseInt(port, 10) + }, + command: "connect", + timeout: timeout2 ?? void 0, + // @ts-expect-error the type supplied by socks for socket_options is wider + // than necessary since socks will always override the host and port + socket_options: this.socketOptions ?? void 0 + }; + const cleanup = (tlsSocket) => { + req.destroy(); + socket.destroy(); + if (tlsSocket) + tlsSocket.destroy(); + }; + debug5("Creating socks proxy connection: %o", socksOpts); + const { socket } = await socks_1.SocksClient.createConnection(socksOpts); + debug5("Successfully created socks proxy connection"); + if (timeout2 !== null) { + socket.setTimeout(timeout2); + socket.on("timeout", () => cleanup()); + } + if (opts.secureEndpoint) { + debug5("Upgrading socket connection to TLS"); + const servername = opts.servername || opts.host; + const tlsSocket = tls.connect({ + ...omit(opts, "host", "path", "port"), + socket, + servername + }); + tlsSocket.once("error", (error) => { + debug5("Socket TLS error", error.message); + cleanup(tlsSocket); + }); + return tlsSocket; + } + return socket; + } + }; + SocksProxyAgent.protocols = [ + "socks", + "socks4", + "socks4a", + "socks5", + "socks5h" + ]; + exports.SocksProxyAgent = SocksProxyAgent; + function omit(obj, ...keys) { + const ret = {}; + let key; + for (key in obj) { + if (!keys.includes(key)) { + ret[key] = obj[key]; + } + } + return ret; + } + } +}); + +// ../testeranto/node_modules/data-uri-to-buffer/dist/common.js +var require_common2 = __commonJS({ + "../testeranto/node_modules/data-uri-to-buffer/dist/common.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.makeDataUriToBuffer = void 0; + var makeDataUriToBuffer = (convert) => (uri) => { + uri = String(uri); + if (!/^data:/i.test(uri)) { + throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")'); + } + uri = uri.replace(/\r?\n/g, ""); + const firstComma = uri.indexOf(","); + if (firstComma === -1 || firstComma <= 4) { + throw new TypeError("malformed data: URI"); + } + const meta = uri.substring(5, firstComma).split(";"); + let charset = ""; + let base64 = false; + const type = meta[0] || "text/plain"; + let typeFull = type; + for (let i = 1; i < meta.length; i++) { + if (meta[i] === "base64") { + base64 = true; + } else if (meta[i]) { + typeFull += `;${meta[i]}`; + if (meta[i].indexOf("charset=") === 0) { + charset = meta[i].substring(8); + } + } + } + if (!meta[0] && !charset.length) { + typeFull += ";charset=US-ASCII"; + charset = "US-ASCII"; + } + const data = unescape(uri.substring(firstComma + 1)); + const buffer = base64 ? convert.base64ToArrayBuffer(data) : convert.stringToBuffer(data); + return { + type, + typeFull, + charset, + buffer + }; + }; + exports.makeDataUriToBuffer = makeDataUriToBuffer; + } +}); + +// ../testeranto/node_modules/data-uri-to-buffer/dist/node.js +var require_node = __commonJS({ + "../testeranto/node_modules/data-uri-to-buffer/dist/node.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.dataUriToBuffer = void 0; + var common_1 = require_common2(); + function nodeBuffertoArrayBuffer(nodeBuf) { + if (nodeBuf.byteLength === nodeBuf.buffer.byteLength) { + return nodeBuf.buffer; + } + const buffer = new ArrayBuffer(nodeBuf.byteLength); + const view = new Uint8Array(buffer); + view.set(nodeBuf); + return buffer; + } + function base64ToArrayBuffer(base64) { + return nodeBuffertoArrayBuffer(Buffer.from(base64, "base64")); + } + function stringToBuffer(str) { + return nodeBuffertoArrayBuffer(Buffer.from(str, "ascii")); + } + exports.dataUriToBuffer = (0, common_1.makeDataUriToBuffer)({ stringToBuffer, base64ToArrayBuffer }); + } +}); + +// ../testeranto/node_modules/get-uri/dist/notmodified.js +var require_notmodified = __commonJS({ + "../testeranto/node_modules/get-uri/dist/notmodified.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var NotModifiedError = class extends Error { + constructor(message) { + super(message || 'Source has not been modified since the provied "cache", re-use previous results'); + this.code = "ENOTMODIFIED"; + } + }; + exports.default = NotModifiedError; + } +}); + +// ../testeranto/node_modules/get-uri/dist/data.js +var require_data = __commonJS({ + "../testeranto/node_modules/get-uri/dist/data.js"(exports) { + "use strict"; + init_cjs_shim(); + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.data = void 0; + var debug_1 = __importDefault2(require_src()); + var stream_1 = __require("stream"); + var crypto_1 = __require("crypto"); + var data_uri_to_buffer_1 = require_node(); + var notmodified_1 = __importDefault2(require_notmodified()); + var debug5 = (0, debug_1.default)("get-uri:data"); + var DataReadable = class extends stream_1.Readable { + constructor(hash, buf) { + super(); + this.push(buf); + this.push(null); + this.hash = hash; + } + }; + var data = async ({ href: uri }, { cache } = {}) => { + const shasum = (0, crypto_1.createHash)("sha1"); + shasum.update(uri); + const hash = shasum.digest("hex"); + debug5('generated SHA1 hash for "data:" URI: %o', hash); + if (cache?.hash === hash) { + debug5("got matching cache SHA1 hash: %o", hash); + throw new notmodified_1.default(); + } else { + debug5('creating Readable stream from "data:" URI buffer'); + const { buffer } = (0, data_uri_to_buffer_1.dataUriToBuffer)(uri); + return new DataReadable(hash, Buffer.from(buffer)); + } + }; + exports.data = data; + } +}); + +// ../testeranto/node_modules/universalify/index.js +var require_universalify = __commonJS({ + "../testeranto/node_modules/universalify/index.js"(exports) { + "use strict"; + init_cjs_shim(); + exports.fromCallback = function(fn) { + return Object.defineProperty(function(...args) { + if (typeof args[args.length - 1] === "function") + fn.apply(this, args); + else { + return new Promise((resolve5, reject) => { + args.push((err, res) => err != null ? reject(err) : resolve5(res)); + fn.apply(this, args); + }); + } + }, "name", { value: fn.name }); + }; + exports.fromPromise = function(fn) { + return Object.defineProperty(function(...args) { + const cb = args[args.length - 1]; + if (typeof cb !== "function") + return fn.apply(this, args); + else { + args.pop(); + fn.apply(this, args).then((r) => cb(null, r), cb); + } + }, "name", { value: fn.name }); + }; + } +}); + +// ../testeranto/node_modules/graceful-fs/polyfills.js +var require_polyfills = __commonJS({ + "../testeranto/node_modules/graceful-fs/polyfills.js"(exports, module) { + init_cjs_shim(); + var constants = __require("constants"); + var origCwd = process.cwd; + var cwd = null; + var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform; + process.cwd = function() { + if (!cwd) + cwd = origCwd.call(process); + return cwd; + }; + try { + process.cwd(); + } catch (er) { + } + if (typeof process.chdir === "function") { + chdir = process.chdir; + process.chdir = function(d) { + cwd = null; + chdir.call(process, d); + }; + if (Object.setPrototypeOf) + Object.setPrototypeOf(process.chdir, chdir); + } + var chdir; + module.exports = patch; + function patch(fs6) { + if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) { + patchLchmod(fs6); + } + if (!fs6.lutimes) { + patchLutimes(fs6); + } + fs6.chown = chownFix(fs6.chown); + fs6.fchown = chownFix(fs6.fchown); + fs6.lchown = chownFix(fs6.lchown); + fs6.chmod = chmodFix(fs6.chmod); + fs6.fchmod = chmodFix(fs6.fchmod); + fs6.lchmod = chmodFix(fs6.lchmod); + fs6.chownSync = chownFixSync(fs6.chownSync); + fs6.fchownSync = chownFixSync(fs6.fchownSync); + fs6.lchownSync = chownFixSync(fs6.lchownSync); + fs6.chmodSync = chmodFixSync(fs6.chmodSync); + fs6.fchmodSync = chmodFixSync(fs6.fchmodSync); + fs6.lchmodSync = chmodFixSync(fs6.lchmodSync); + fs6.stat = statFix(fs6.stat); + fs6.fstat = statFix(fs6.fstat); + fs6.lstat = statFix(fs6.lstat); + fs6.statSync = statFixSync(fs6.statSync); + fs6.fstatSync = statFixSync(fs6.fstatSync); + fs6.lstatSync = statFixSync(fs6.lstatSync); + if (fs6.chmod && !fs6.lchmod) { + fs6.lchmod = function(path10, mode, cb) { + if (cb) + process.nextTick(cb); + }; + fs6.lchmodSync = function() { + }; + } + if (fs6.chown && !fs6.lchown) { + fs6.lchown = function(path10, uid, gid, cb) { + if (cb) + process.nextTick(cb); + }; + fs6.lchownSync = function() { + }; + } + if (platform === "win32") { + fs6.rename = typeof fs6.rename !== "function" ? fs6.rename : function(fs$rename) { + function rename2(from2, to, cb) { + var start = Date.now(); + var backoff = 0; + fs$rename(from2, to, function CB(er) { + if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) { + setTimeout(function() { + fs6.stat(to, function(stater, st) { + if (stater && stater.code === "ENOENT") + fs$rename(from2, to, CB); + else + cb(er); + }); + }, backoff); + if (backoff < 100) + backoff += 10; + return; + } + if (cb) + cb(er); + }); + } + if (Object.setPrototypeOf) + Object.setPrototypeOf(rename2, fs$rename); + return rename2; + }(fs6.rename); + } + fs6.read = typeof fs6.read !== "function" ? fs6.read : function(fs$read) { + function read(fd, buffer, offset, length, position, callback_) { + var callback; + if (callback_ && typeof callback_ === "function") { + var eagCounter = 0; + callback = function(er, _, __) { + if (er && er.code === "EAGAIN" && eagCounter < 10) { + eagCounter++; + return fs$read.call(fs6, fd, buffer, offset, length, position, callback); + } + callback_.apply(this, arguments); + }; + } + return fs$read.call(fs6, fd, buffer, offset, length, position, callback); + } + if (Object.setPrototypeOf) + Object.setPrototypeOf(read, fs$read); + return read; + }(fs6.read); + fs6.readSync = typeof fs6.readSync !== "function" ? fs6.readSync : function(fs$readSync) { + return function(fd, buffer, offset, length, position) { + var eagCounter = 0; + while (true) { + try { + return fs$readSync.call(fs6, fd, buffer, offset, length, position); + } catch (er) { + if (er.code === "EAGAIN" && eagCounter < 10) { + eagCounter++; + continue; + } + throw er; + } + } + }; + }(fs6.readSync); + function patchLchmod(fs7) { + fs7.lchmod = function(path10, mode, callback) { + fs7.open( + path10, + constants.O_WRONLY | constants.O_SYMLINK, + mode, + function(err, fd) { + if (err) { + if (callback) + callback(err); + return; + } + fs7.fchmod(fd, mode, function(err2) { + fs7.close(fd, function(err22) { + if (callback) + callback(err2 || err22); + }); + }); + } + ); + }; + fs7.lchmodSync = function(path10, mode) { + var fd = fs7.openSync(path10, constants.O_WRONLY | constants.O_SYMLINK, mode); + var threw = true; + var ret; + try { + ret = fs7.fchmodSync(fd, mode); + threw = false; + } finally { + if (threw) { + try { + fs7.closeSync(fd); + } catch (er) { + } + } else { + fs7.closeSync(fd); + } + } + return ret; + }; + } + function patchLutimes(fs7) { + if (constants.hasOwnProperty("O_SYMLINK") && fs7.futimes) { + fs7.lutimes = function(path10, at, mt, cb) { + fs7.open(path10, constants.O_SYMLINK, function(er, fd) { + if (er) { + if (cb) + cb(er); + return; + } + fs7.futimes(fd, at, mt, function(er2) { + fs7.close(fd, function(er22) { + if (cb) + cb(er2 || er22); + }); + }); + }); + }; + fs7.lutimesSync = function(path10, at, mt) { + var fd = fs7.openSync(path10, constants.O_SYMLINK); + var ret; + var threw = true; + try { + ret = fs7.futimesSync(fd, at, mt); + threw = false; + } finally { + if (threw) { + try { + fs7.closeSync(fd); + } catch (er) { + } + } else { + fs7.closeSync(fd); + } + } + return ret; + }; + } else if (fs7.futimes) { + fs7.lutimes = function(_a2, _b2, _c2, cb) { + if (cb) + process.nextTick(cb); + }; + fs7.lutimesSync = function() { + }; + } + } + function chmodFix(orig) { + if (!orig) + return orig; + return function(target, mode, cb) { + return orig.call(fs6, target, mode, function(er) { + if (chownErOk(er)) + er = null; + if (cb) + cb.apply(this, arguments); + }); + }; + } + function chmodFixSync(orig) { + if (!orig) + return orig; + return function(target, mode) { + try { + return orig.call(fs6, target, mode); + } catch (er) { + if (!chownErOk(er)) + throw er; + } + }; + } + function chownFix(orig) { + if (!orig) + return orig; + return function(target, uid, gid, cb) { + return orig.call(fs6, target, uid, gid, function(er) { + if (chownErOk(er)) + er = null; + if (cb) + cb.apply(this, arguments); + }); + }; + } + function chownFixSync(orig) { + if (!orig) + return orig; + return function(target, uid, gid) { + try { + return orig.call(fs6, target, uid, gid); + } catch (er) { + if (!chownErOk(er)) + throw er; + } + }; + } + function statFix(orig) { + if (!orig) + return orig; + return function(target, options, cb) { + if (typeof options === "function") { + cb = options; + options = null; + } + function callback(er, stats) { + if (stats) { + if (stats.uid < 0) + stats.uid += 4294967296; + if (stats.gid < 0) + stats.gid += 4294967296; + } + if (cb) + cb.apply(this, arguments); + } + return options ? orig.call(fs6, target, options, callback) : orig.call(fs6, target, callback); + }; + } + function statFixSync(orig) { + if (!orig) + return orig; + return function(target, options) { + var stats = options ? orig.call(fs6, target, options) : orig.call(fs6, target); + if (stats) { + if (stats.uid < 0) + stats.uid += 4294967296; + if (stats.gid < 0) + stats.gid += 4294967296; + } + return stats; + }; + } + function chownErOk(er) { + if (!er) + return true; + if (er.code === "ENOSYS") + return true; + var nonroot = !process.getuid || process.getuid() !== 0; + if (nonroot) { + if (er.code === "EINVAL" || er.code === "EPERM") + return true; + } + return false; + } + } + } +}); + +// ../testeranto/node_modules/graceful-fs/legacy-streams.js +var require_legacy_streams = __commonJS({ + "../testeranto/node_modules/graceful-fs/legacy-streams.js"(exports, module) { + init_cjs_shim(); + var Stream = __require("stream").Stream; + module.exports = legacy; + function legacy(fs6) { + return { + ReadStream, + WriteStream + }; + function ReadStream(path10, options) { + if (!(this instanceof ReadStream)) + return new ReadStream(path10, options); + Stream.call(this); + var self2 = this; + this.path = path10; + this.fd = null; + this.readable = true; + this.paused = false; + this.flags = "r"; + this.mode = 438; + this.bufferSize = 64 * 1024; + options = options || {}; + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; + } + if (this.encoding) + this.setEncoding(this.encoding); + if (this.start !== void 0) { + if ("number" !== typeof this.start) { + throw TypeError("start must be a Number"); + } + if (this.end === void 0) { + this.end = Infinity; + } else if ("number" !== typeof this.end) { + throw TypeError("end must be a Number"); + } + if (this.start > this.end) { + throw new Error("start must be <= end"); + } + this.pos = this.start; + } + if (this.fd !== null) { + process.nextTick(function() { + self2._read(); + }); + return; + } + fs6.open(this.path, this.flags, this.mode, function(err, fd) { + if (err) { + self2.emit("error", err); + self2.readable = false; + return; + } + self2.fd = fd; + self2.emit("open", fd); + self2._read(); + }); + } + function WriteStream(path10, options) { + if (!(this instanceof WriteStream)) + return new WriteStream(path10, options); + Stream.call(this); + this.path = path10; + this.fd = null; + this.writable = true; + this.flags = "w"; + this.encoding = "binary"; + this.mode = 438; + this.bytesWritten = 0; + options = options || {}; + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; + } + if (this.start !== void 0) { + if ("number" !== typeof this.start) { + throw TypeError("start must be a Number"); + } + if (this.start < 0) { + throw new Error("start must be >= zero"); + } + this.pos = this.start; + } + this.busy = false; + this._queue = []; + if (this.fd === null) { + this._open = fs6.open; + this._queue.push([this._open, this.path, this.flags, this.mode, void 0]); + this.flush(); + } + } + } + } +}); + +// ../testeranto/node_modules/graceful-fs/clone.js +var require_clone = __commonJS({ + "../testeranto/node_modules/graceful-fs/clone.js"(exports, module) { + "use strict"; + init_cjs_shim(); + module.exports = clone; + var getPrototypeOf = Object.getPrototypeOf || function(obj) { + return obj.__proto__; + }; + function clone(obj) { + if (obj === null || typeof obj !== "object") + return obj; + if (obj instanceof Object) + var copy = { __proto__: getPrototypeOf(obj) }; + else + var copy = /* @__PURE__ */ Object.create(null); + Object.getOwnPropertyNames(obj).forEach(function(key) { + Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key)); + }); + return copy; + } + } +}); + +// ../testeranto/node_modules/graceful-fs/graceful-fs.js +var require_graceful_fs = __commonJS({ + "../testeranto/node_modules/graceful-fs/graceful-fs.js"(exports, module) { + init_cjs_shim(); + var fs6 = __require("fs"); + var polyfills = require_polyfills(); + var legacy = require_legacy_streams(); + var clone = require_clone(); + var util2 = __require("util"); + var gracefulQueue; + var previousSymbol; + if (typeof Symbol === "function" && typeof Symbol.for === "function") { + gracefulQueue = Symbol.for("graceful-fs.queue"); + previousSymbol = Symbol.for("graceful-fs.previous"); + } else { + gracefulQueue = "___graceful-fs.queue"; + previousSymbol = "___graceful-fs.previous"; + } + function noop() { + } + function publishQueue(context, queue2) { + Object.defineProperty(context, gracefulQueue, { + get: function() { + return queue2; + } + }); + } + var debug5 = noop; + if (util2.debuglog) + debug5 = util2.debuglog("gfs4"); + else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) + debug5 = function() { + var m = util2.format.apply(util2, arguments); + m = "GFS4: " + m.split(/\n/).join("\nGFS4: "); + console.error(m); + }; + if (!fs6[gracefulQueue]) { + queue = global[gracefulQueue] || []; + publishQueue(fs6, queue); + fs6.close = function(fs$close) { + function close(fd, cb) { + return fs$close.call(fs6, fd, function(err) { + if (!err) { + resetQueue(); + } + if (typeof cb === "function") + cb.apply(this, arguments); + }); + } + Object.defineProperty(close, previousSymbol, { + value: fs$close + }); + return close; + }(fs6.close); + fs6.closeSync = function(fs$closeSync) { + function closeSync(fd) { + fs$closeSync.apply(fs6, arguments); + resetQueue(); + } + Object.defineProperty(closeSync, previousSymbol, { + value: fs$closeSync + }); + return closeSync; + }(fs6.closeSync); + if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) { + process.on("exit", function() { + debug5(fs6[gracefulQueue]); + __require("assert").equal(fs6[gracefulQueue].length, 0); + }); + } + } + var queue; + if (!global[gracefulQueue]) { + publishQueue(global, fs6[gracefulQueue]); + } + module.exports = patch(clone(fs6)); + if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs6.__patched) { + module.exports = patch(fs6); + fs6.__patched = true; + } + function patch(fs7) { + polyfills(fs7); + fs7.gracefulify = patch; + fs7.createReadStream = createReadStream; + fs7.createWriteStream = createWriteStream; + var fs$readFile = fs7.readFile; + fs7.readFile = readFile; + function readFile(path10, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$readFile(path10, options, cb); + function go$readFile(path11, options2, cb2, startTime) { + return fs$readFile(path11, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$readFile, [path11, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$writeFile = fs7.writeFile; + fs7.writeFile = writeFile2; + function writeFile2(path10, data, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$writeFile(path10, data, options, cb); + function go$writeFile(path11, data2, options2, cb2, startTime) { + return fs$writeFile(path11, data2, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$writeFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$appendFile = fs7.appendFile; + if (fs$appendFile) + fs7.appendFile = appendFile; + function appendFile(path10, data, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$appendFile(path10, data, options, cb); + function go$appendFile(path11, data2, options2, cb2, startTime) { + return fs$appendFile(path11, data2, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$appendFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$copyFile = fs7.copyFile; + if (fs$copyFile) + fs7.copyFile = copyFile; + function copyFile(src, dest, flags, cb) { + if (typeof flags === "function") { + cb = flags; + flags = 0; + } + return go$copyFile(src, dest, flags, cb); + function go$copyFile(src2, dest2, flags2, cb2, startTime) { + return fs$copyFile(src2, dest2, flags2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$readdir = fs7.readdir; + fs7.readdir = readdir; + var noReaddirOptionVersions = /^v[0-5]\./; + function readdir(path10, options, cb) { + if (typeof options === "function") + cb = options, options = null; + var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path11, options2, cb2, startTime) { + return fs$readdir(path11, fs$readdirCallback( + path11, + options2, + cb2, + startTime + )); + } : function go$readdir2(path11, options2, cb2, startTime) { + return fs$readdir(path11, options2, fs$readdirCallback( + path11, + options2, + cb2, + startTime + )); + }; + return go$readdir(path10, options, cb); + function fs$readdirCallback(path11, options2, cb2, startTime) { + return function(err, files) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([ + go$readdir, + [path11, options2, cb2], + err, + startTime || Date.now(), + Date.now() + ]); + else { + if (files && files.sort) + files.sort(); + if (typeof cb2 === "function") + cb2.call(this, err, files); + } + }; + } + } + if (process.version.substr(0, 4) === "v0.8") { + var legStreams = legacy(fs7); + ReadStream = legStreams.ReadStream; + WriteStream = legStreams.WriteStream; + } + var fs$ReadStream = fs7.ReadStream; + if (fs$ReadStream) { + ReadStream.prototype = Object.create(fs$ReadStream.prototype); + ReadStream.prototype.open = ReadStream$open; + } + var fs$WriteStream = fs7.WriteStream; + if (fs$WriteStream) { + WriteStream.prototype = Object.create(fs$WriteStream.prototype); + WriteStream.prototype.open = WriteStream$open; + } + Object.defineProperty(fs7, "ReadStream", { + get: function() { + return ReadStream; + }, + set: function(val) { + ReadStream = val; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(fs7, "WriteStream", { + get: function() { + return WriteStream; + }, + set: function(val) { + WriteStream = val; + }, + enumerable: true, + configurable: true + }); + var FileReadStream = ReadStream; + Object.defineProperty(fs7, "FileReadStream", { + get: function() { + return FileReadStream; + }, + set: function(val) { + FileReadStream = val; + }, + enumerable: true, + configurable: true + }); + var FileWriteStream = WriteStream; + Object.defineProperty(fs7, "FileWriteStream", { + get: function() { + return FileWriteStream; + }, + set: function(val) { + FileWriteStream = val; + }, + enumerable: true, + configurable: true + }); + function ReadStream(path10, options) { + if (this instanceof ReadStream) + return fs$ReadStream.apply(this, arguments), this; + else + return ReadStream.apply(Object.create(ReadStream.prototype), arguments); + } + function ReadStream$open() { + var that = this; + open(that.path, that.flags, that.mode, function(err, fd) { + if (err) { + if (that.autoClose) + that.destroy(); + that.emit("error", err); + } else { + that.fd = fd; + that.emit("open", fd); + that.read(); + } + }); + } + function WriteStream(path10, options) { + if (this instanceof WriteStream) + return fs$WriteStream.apply(this, arguments), this; + else + return WriteStream.apply(Object.create(WriteStream.prototype), arguments); + } + function WriteStream$open() { + var that = this; + open(that.path, that.flags, that.mode, function(err, fd) { + if (err) { + that.destroy(); + that.emit("error", err); + } else { + that.fd = fd; + that.emit("open", fd); + } + }); + } + function createReadStream(path10, options) { + return new fs7.ReadStream(path10, options); + } + function createWriteStream(path10, options) { + return new fs7.WriteStream(path10, options); + } + var fs$open = fs7.open; + fs7.open = open; + function open(path10, flags, mode, cb) { + if (typeof mode === "function") + cb = mode, mode = null; + return go$open(path10, flags, mode, cb); + function go$open(path11, flags2, mode2, cb2, startTime) { + return fs$open(path11, flags2, mode2, function(err, fd) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$open, [path11, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + return fs7; + } + function enqueue(elem) { + debug5("ENQUEUE", elem[0].name, elem[1]); + fs6[gracefulQueue].push(elem); + retry(); + } + var retryTimer; + function resetQueue() { + var now = Date.now(); + for (var i = 0; i < fs6[gracefulQueue].length; ++i) { + if (fs6[gracefulQueue][i].length > 2) { + fs6[gracefulQueue][i][3] = now; + fs6[gracefulQueue][i][4] = now; + } + } + retry(); + } + function retry() { + clearTimeout(retryTimer); + retryTimer = void 0; + if (fs6[gracefulQueue].length === 0) + return; + var elem = fs6[gracefulQueue].shift(); + var fn = elem[0]; + var args = elem[1]; + var err = elem[2]; + var startTime = elem[3]; + var lastTime = elem[4]; + if (startTime === void 0) { + debug5("RETRY", fn.name, args); + fn.apply(null, args); + } else if (Date.now() - startTime >= 6e4) { + debug5("TIMEOUT", fn.name, args); + var cb = args.pop(); + if (typeof cb === "function") + cb.call(null, err); + } else { + var sinceAttempt = Date.now() - lastTime; + var sinceStart = Math.max(lastTime - startTime, 1); + var desiredDelay = Math.min(sinceStart * 1.2, 100); + if (sinceAttempt >= desiredDelay) { + debug5("RETRY", fn.name, args); + fn.apply(null, args.concat([startTime])); + } else { + fs6[gracefulQueue].push(elem); + } + } + if (retryTimer === void 0) { + retryTimer = setTimeout(retry, 0); + } + } + } +}); + +// ../testeranto/node_modules/fs-extra/lib/fs/index.js +var require_fs = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/fs/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var u = require_universalify().fromCallback; + var fs6 = require_graceful_fs(); + var api = [ + "access", + "appendFile", + "chmod", + "chown", + "close", + "copyFile", + "fchmod", + "fchown", + "fdatasync", + "fstat", + "fsync", + "ftruncate", + "futimes", + "lchmod", + "lchown", + "link", + "lstat", + "mkdir", + "mkdtemp", + "open", + "opendir", + "readdir", + "readFile", + "readlink", + "realpath", + "rename", + "rm", + "rmdir", + "stat", + "symlink", + "truncate", + "unlink", + "utimes", + "writeFile" + ].filter((key) => { + return typeof fs6[key] === "function"; + }); + Object.assign(exports, fs6); + api.forEach((method) => { + exports[method] = u(fs6[method]); + }); + exports.exists = function(filename, callback) { + if (typeof callback === "function") { + return fs6.exists(filename, callback); + } + return new Promise((resolve5) => { + return fs6.exists(filename, resolve5); + }); + }; + exports.read = function(fd, buffer, offset, length, position, callback) { + if (typeof callback === "function") { + return fs6.read(fd, buffer, offset, length, position, callback); + } + return new Promise((resolve5, reject) => { + fs6.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => { + if (err) + return reject(err); + resolve5({ bytesRead, buffer: buffer2 }); + }); + }); + }; + exports.write = function(fd, buffer, ...args) { + if (typeof args[args.length - 1] === "function") { + return fs6.write(fd, buffer, ...args); + } + return new Promise((resolve5, reject) => { + fs6.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => { + if (err) + return reject(err); + resolve5({ bytesWritten, buffer: buffer2 }); + }); + }); + }; + exports.readv = function(fd, buffers, ...args) { + if (typeof args[args.length - 1] === "function") { + return fs6.readv(fd, buffers, ...args); + } + return new Promise((resolve5, reject) => { + fs6.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => { + if (err) + return reject(err); + resolve5({ bytesRead, buffers: buffers2 }); + }); + }); + }; + exports.writev = function(fd, buffers, ...args) { + if (typeof args[args.length - 1] === "function") { + return fs6.writev(fd, buffers, ...args); + } + return new Promise((resolve5, reject) => { + fs6.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => { + if (err) + return reject(err); + resolve5({ bytesWritten, buffers: buffers2 }); + }); + }); + }; + if (typeof fs6.realpath.native === "function") { + exports.realpath.native = u(fs6.realpath.native); + } else { + process.emitWarning( + "fs.realpath.native is not a function. Is fs being monkey-patched?", + "Warning", + "fs-extra-WARN0003" + ); + } + } +}); + +// ../testeranto/node_modules/fs-extra/lib/mkdirs/utils.js +var require_utils3 = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var path10 = __require("path"); + module.exports.checkPath = function checkPath(pth) { + if (process.platform === "win32") { + const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path10.parse(pth).root, "")); + if (pathHasInvalidWinCharacters) { + const error = new Error(`Path contains invalid characters: ${pth}`); + error.code = "EINVAL"; + throw error; + } + } + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/mkdirs/make-dir.js +var require_make_dir = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var fs6 = require_fs(); + var { checkPath } = require_utils3(); + var getMode = (options) => { + const defaults = { mode: 511 }; + if (typeof options === "number") + return options; + return { ...defaults, ...options }.mode; + }; + module.exports.makeDir = async (dir, options) => { + checkPath(dir); + return fs6.mkdir(dir, { + mode: getMode(options), + recursive: true + }); + }; + module.exports.makeDirSync = (dir, options) => { + checkPath(dir); + return fs6.mkdirSync(dir, { + mode: getMode(options), + recursive: true + }); + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/mkdirs/index.js +var require_mkdirs = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/mkdirs/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var u = require_universalify().fromPromise; + var { makeDir: _makeDir, makeDirSync } = require_make_dir(); + var makeDir = u(_makeDir); + module.exports = { + mkdirs: makeDir, + mkdirsSync: makeDirSync, + // alias + mkdirp: makeDir, + mkdirpSync: makeDirSync, + ensureDir: makeDir, + ensureDirSync: makeDirSync + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/path-exists/index.js +var require_path_exists = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/path-exists/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var u = require_universalify().fromPromise; + var fs6 = require_fs(); + function pathExists(path10) { + return fs6.access(path10).then(() => true).catch(() => false); + } + module.exports = { + pathExists: u(pathExists), + pathExistsSync: fs6.existsSync + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/util/utimes.js +var require_utimes = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/util/utimes.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var fs6 = require_fs(); + var u = require_universalify().fromPromise; + async function utimesMillis(path10, atime, mtime) { + const fd = await fs6.open(path10, "r+"); + let closeErr = null; + try { + await fs6.futimes(fd, atime, mtime); + } finally { + try { + await fs6.close(fd); + } catch (e) { + closeErr = e; + } + } + if (closeErr) { + throw closeErr; + } + } + function utimesMillisSync(path10, atime, mtime) { + const fd = fs6.openSync(path10, "r+"); + fs6.futimesSync(fd, atime, mtime); + return fs6.closeSync(fd); + } + module.exports = { + utimesMillis: u(utimesMillis), + utimesMillisSync + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/util/stat.js +var require_stat = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/util/stat.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var fs6 = require_fs(); + var path10 = __require("path"); + var u = require_universalify().fromPromise; + function getStats(src, dest, opts) { + const statFunc = opts.dereference ? (file) => fs6.stat(file, { bigint: true }) : (file) => fs6.lstat(file, { bigint: true }); + return Promise.all([ + statFunc(src), + statFunc(dest).catch((err) => { + if (err.code === "ENOENT") + return null; + throw err; + }) + ]).then(([srcStat, destStat]) => ({ srcStat, destStat })); + } + function getStatsSync(src, dest, opts) { + let destStat; + const statFunc = opts.dereference ? (file) => fs6.statSync(file, { bigint: true }) : (file) => fs6.lstatSync(file, { bigint: true }); + const srcStat = statFunc(src); + try { + destStat = statFunc(dest); + } catch (err) { + if (err.code === "ENOENT") + return { srcStat, destStat: null }; + throw err; + } + return { srcStat, destStat }; + } + async function checkPaths(src, dest, funcName, opts) { + const { srcStat, destStat } = await getStats(src, dest, opts); + if (destStat) { + if (areIdentical(srcStat, destStat)) { + const srcBaseName = path10.basename(src); + const destBaseName = path10.basename(dest); + if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) { + return { srcStat, destStat, isChangingCase: true }; + } + throw new Error("Source and destination must not be the same."); + } + if (srcStat.isDirectory() && !destStat.isDirectory()) { + throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`); + } + if (!srcStat.isDirectory() && destStat.isDirectory()) { + throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`); + } + } + if (srcStat.isDirectory() && isSrcSubdir(src, dest)) { + throw new Error(errMsg(src, dest, funcName)); + } + return { srcStat, destStat }; + } + function checkPathsSync(src, dest, funcName, opts) { + const { srcStat, destStat } = getStatsSync(src, dest, opts); + if (destStat) { + if (areIdentical(srcStat, destStat)) { + const srcBaseName = path10.basename(src); + const destBaseName = path10.basename(dest); + if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) { + return { srcStat, destStat, isChangingCase: true }; + } + throw new Error("Source and destination must not be the same."); + } + if (srcStat.isDirectory() && !destStat.isDirectory()) { + throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`); + } + if (!srcStat.isDirectory() && destStat.isDirectory()) { + throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`); + } + } + if (srcStat.isDirectory() && isSrcSubdir(src, dest)) { + throw new Error(errMsg(src, dest, funcName)); + } + return { srcStat, destStat }; + } + async function checkParentPaths(src, srcStat, dest, funcName) { + const srcParent = path10.resolve(path10.dirname(src)); + const destParent = path10.resolve(path10.dirname(dest)); + if (destParent === srcParent || destParent === path10.parse(destParent).root) + return; + let destStat; + try { + destStat = await fs6.stat(destParent, { bigint: true }); + } catch (err) { + if (err.code === "ENOENT") + return; + throw err; + } + if (areIdentical(srcStat, destStat)) { + throw new Error(errMsg(src, dest, funcName)); + } + return checkParentPaths(src, srcStat, destParent, funcName); + } + function checkParentPathsSync(src, srcStat, dest, funcName) { + const srcParent = path10.resolve(path10.dirname(src)); + const destParent = path10.resolve(path10.dirname(dest)); + if (destParent === srcParent || destParent === path10.parse(destParent).root) + return; + let destStat; + try { + destStat = fs6.statSync(destParent, { bigint: true }); + } catch (err) { + if (err.code === "ENOENT") + return; + throw err; + } + if (areIdentical(srcStat, destStat)) { + throw new Error(errMsg(src, dest, funcName)); + } + return checkParentPathsSync(src, srcStat, destParent, funcName); + } + function areIdentical(srcStat, destStat) { + return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev; + } + function isSrcSubdir(src, dest) { + const srcArr = path10.resolve(src).split(path10.sep).filter((i) => i); + const destArr = path10.resolve(dest).split(path10.sep).filter((i) => i); + return srcArr.every((cur, i) => destArr[i] === cur); + } + function errMsg(src, dest, funcName) { + return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`; + } + module.exports = { + // checkPaths + checkPaths: u(checkPaths), + checkPathsSync, + // checkParent + checkParentPaths: u(checkParentPaths), + checkParentPathsSync, + // Misc + isSrcSubdir, + areIdentical + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/copy/copy.js +var require_copy = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/copy/copy.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var fs6 = require_fs(); + var path10 = __require("path"); + var { mkdirs } = require_mkdirs(); + var { pathExists } = require_path_exists(); + var { utimesMillis } = require_utimes(); + var stat = require_stat(); + async function copy(src, dest, opts = {}) { + if (typeof opts === "function") { + opts = { filter: opts }; + } + opts.clobber = "clobber" in opts ? !!opts.clobber : true; + opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber; + if (opts.preserveTimestamps && process.arch === "ia32") { + process.emitWarning( + "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n see https://github.com/jprichardson/node-fs-extra/issues/269", + "Warning", + "fs-extra-WARN0001" + ); + } + const { srcStat, destStat } = await stat.checkPaths(src, dest, "copy", opts); + await stat.checkParentPaths(src, srcStat, dest, "copy"); + const include = await runFilter(src, dest, opts); + if (!include) + return; + const destParent = path10.dirname(dest); + const dirExists = await pathExists(destParent); + if (!dirExists) { + await mkdirs(destParent); + } + await getStatsAndPerformCopy(destStat, src, dest, opts); + } + async function runFilter(src, dest, opts) { + if (!opts.filter) + return true; + return opts.filter(src, dest); + } + async function getStatsAndPerformCopy(destStat, src, dest, opts) { + const statFn = opts.dereference ? fs6.stat : fs6.lstat; + const srcStat = await statFn(src); + if (srcStat.isDirectory()) + return onDir(srcStat, destStat, src, dest, opts); + if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) + return onFile(srcStat, destStat, src, dest, opts); + if (srcStat.isSymbolicLink()) + return onLink(destStat, src, dest, opts); + if (srcStat.isSocket()) + throw new Error(`Cannot copy a socket file: ${src}`); + if (srcStat.isFIFO()) + throw new Error(`Cannot copy a FIFO pipe: ${src}`); + throw new Error(`Unknown file: ${src}`); + } + async function onFile(srcStat, destStat, src, dest, opts) { + if (!destStat) + return copyFile(srcStat, src, dest, opts); + if (opts.overwrite) { + await fs6.unlink(dest); + return copyFile(srcStat, src, dest, opts); + } + if (opts.errorOnExist) { + throw new Error(`'${dest}' already exists`); + } + } + async function copyFile(srcStat, src, dest, opts) { + await fs6.copyFile(src, dest); + if (opts.preserveTimestamps) { + if (fileIsNotWritable(srcStat.mode)) { + await makeFileWritable(dest, srcStat.mode); + } + const updatedSrcStat = await fs6.stat(src); + await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime); + } + return fs6.chmod(dest, srcStat.mode); + } + function fileIsNotWritable(srcMode) { + return (srcMode & 128) === 0; + } + function makeFileWritable(dest, srcMode) { + return fs6.chmod(dest, srcMode | 128); + } + async function onDir(srcStat, destStat, src, dest, opts) { + if (!destStat) { + await fs6.mkdir(dest); + } + const items = await fs6.readdir(src); + await Promise.all(items.map(async (item) => { + const srcItem = path10.join(src, item); + const destItem = path10.join(dest, item); + const include = await runFilter(srcItem, destItem, opts); + if (!include) + return; + const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts); + return getStatsAndPerformCopy(destStat2, srcItem, destItem, opts); + })); + if (!destStat) { + await fs6.chmod(dest, srcStat.mode); + } + } + async function onLink(destStat, src, dest, opts) { + let resolvedSrc = await fs6.readlink(src); + if (opts.dereference) { + resolvedSrc = path10.resolve(process.cwd(), resolvedSrc); + } + if (!destStat) { + return fs6.symlink(resolvedSrc, dest); + } + let resolvedDest = null; + try { + resolvedDest = await fs6.readlink(dest); + } catch (e) { + if (e.code === "EINVAL" || e.code === "UNKNOWN") + return fs6.symlink(resolvedSrc, dest); + throw e; + } + if (opts.dereference) { + resolvedDest = path10.resolve(process.cwd(), resolvedDest); + } + if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) { + throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`); + } + if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) { + throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`); + } + await fs6.unlink(dest); + return fs6.symlink(resolvedSrc, dest); + } + module.exports = copy; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/copy/copy-sync.js +var require_copy_sync = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var fs6 = require_graceful_fs(); + var path10 = __require("path"); + var mkdirsSync = require_mkdirs().mkdirsSync; + var utimesMillisSync = require_utimes().utimesMillisSync; + var stat = require_stat(); + function copySync(src, dest, opts) { + if (typeof opts === "function") { + opts = { filter: opts }; + } + opts = opts || {}; + opts.clobber = "clobber" in opts ? !!opts.clobber : true; + opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber; + if (opts.preserveTimestamps && process.arch === "ia32") { + process.emitWarning( + "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n see https://github.com/jprichardson/node-fs-extra/issues/269", + "Warning", + "fs-extra-WARN0002" + ); + } + const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts); + stat.checkParentPathsSync(src, srcStat, dest, "copy"); + if (opts.filter && !opts.filter(src, dest)) + return; + const destParent = path10.dirname(dest); + if (!fs6.existsSync(destParent)) + mkdirsSync(destParent); + return getStats(destStat, src, dest, opts); + } + function getStats(destStat, src, dest, opts) { + const statSync3 = opts.dereference ? fs6.statSync : fs6.lstatSync; + const srcStat = statSync3(src); + if (srcStat.isDirectory()) + return onDir(srcStat, destStat, src, dest, opts); + else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) + return onFile(srcStat, destStat, src, dest, opts); + else if (srcStat.isSymbolicLink()) + return onLink(destStat, src, dest, opts); + else if (srcStat.isSocket()) + throw new Error(`Cannot copy a socket file: ${src}`); + else if (srcStat.isFIFO()) + throw new Error(`Cannot copy a FIFO pipe: ${src}`); + throw new Error(`Unknown file: ${src}`); + } + function onFile(srcStat, destStat, src, dest, opts) { + if (!destStat) + return copyFile(srcStat, src, dest, opts); + return mayCopyFile(srcStat, src, dest, opts); + } + function mayCopyFile(srcStat, src, dest, opts) { + if (opts.overwrite) { + fs6.unlinkSync(dest); + return copyFile(srcStat, src, dest, opts); + } else if (opts.errorOnExist) { + throw new Error(`'${dest}' already exists`); + } + } + function copyFile(srcStat, src, dest, opts) { + fs6.copyFileSync(src, dest); + if (opts.preserveTimestamps) + handleTimestamps(srcStat.mode, src, dest); + return setDestMode(dest, srcStat.mode); + } + function handleTimestamps(srcMode, src, dest) { + if (fileIsNotWritable(srcMode)) + makeFileWritable(dest, srcMode); + return setDestTimestamps(src, dest); + } + function fileIsNotWritable(srcMode) { + return (srcMode & 128) === 0; + } + function makeFileWritable(dest, srcMode) { + return setDestMode(dest, srcMode | 128); + } + function setDestMode(dest, srcMode) { + return fs6.chmodSync(dest, srcMode); + } + function setDestTimestamps(src, dest) { + const updatedSrcStat = fs6.statSync(src); + return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime); + } + function onDir(srcStat, destStat, src, dest, opts) { + if (!destStat) + return mkDirAndCopy(srcStat.mode, src, dest, opts); + return copyDir(src, dest, opts); + } + function mkDirAndCopy(srcMode, src, dest, opts) { + fs6.mkdirSync(dest); + copyDir(src, dest, opts); + return setDestMode(dest, srcMode); + } + function copyDir(src, dest, opts) { + fs6.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts)); + } + function copyDirItem(item, src, dest, opts) { + const srcItem = path10.join(src, item); + const destItem = path10.join(dest, item); + if (opts.filter && !opts.filter(srcItem, destItem)) + return; + const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts); + return getStats(destStat, srcItem, destItem, opts); + } + function onLink(destStat, src, dest, opts) { + let resolvedSrc = fs6.readlinkSync(src); + if (opts.dereference) { + resolvedSrc = path10.resolve(process.cwd(), resolvedSrc); + } + if (!destStat) { + return fs6.symlinkSync(resolvedSrc, dest); + } else { + let resolvedDest; + try { + resolvedDest = fs6.readlinkSync(dest); + } catch (err) { + if (err.code === "EINVAL" || err.code === "UNKNOWN") + return fs6.symlinkSync(resolvedSrc, dest); + throw err; + } + if (opts.dereference) { + resolvedDest = path10.resolve(process.cwd(), resolvedDest); + } + if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) { + throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`); + } + if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) { + throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`); + } + return copyLink(resolvedSrc, dest); + } + } + function copyLink(resolvedSrc, dest) { + fs6.unlinkSync(dest); + return fs6.symlinkSync(resolvedSrc, dest); + } + module.exports = copySync; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/copy/index.js +var require_copy2 = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/copy/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var u = require_universalify().fromPromise; + module.exports = { + copy: u(require_copy()), + copySync: require_copy_sync() + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/remove/index.js +var require_remove = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/remove/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var fs6 = require_graceful_fs(); + var u = require_universalify().fromCallback; + function remove(path10, callback) { + fs6.rm(path10, { recursive: true, force: true }, callback); + } + function removeSync(path10) { + fs6.rmSync(path10, { recursive: true, force: true }); + } + module.exports = { + remove: u(remove), + removeSync + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/empty/index.js +var require_empty = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/empty/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var u = require_universalify().fromPromise; + var fs6 = require_fs(); + var path10 = __require("path"); + var mkdir = require_mkdirs(); + var remove = require_remove(); + var emptyDir = u(async function emptyDir2(dir) { + let items; + try { + items = await fs6.readdir(dir); + } catch { + return mkdir.mkdirs(dir); + } + return Promise.all(items.map((item) => remove.remove(path10.join(dir, item)))); + }); + function emptyDirSync(dir) { + let items; + try { + items = fs6.readdirSync(dir); + } catch { + return mkdir.mkdirsSync(dir); + } + items.forEach((item) => { + item = path10.join(dir, item); + remove.removeSync(item); + }); + } + module.exports = { + emptyDirSync, + emptydirSync: emptyDirSync, + emptyDir, + emptydir: emptyDir + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/ensure/file.js +var require_file = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/ensure/file.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var u = require_universalify().fromPromise; + var path10 = __require("path"); + var fs6 = require_fs(); + var mkdir = require_mkdirs(); + async function createFile(file) { + let stats; + try { + stats = await fs6.stat(file); + } catch { + } + if (stats && stats.isFile()) + return; + const dir = path10.dirname(file); + let dirStats = null; + try { + dirStats = await fs6.stat(dir); + } catch (err) { + if (err.code === "ENOENT") { + await mkdir.mkdirs(dir); + await fs6.writeFile(file, ""); + return; + } else { + throw err; + } + } + if (dirStats.isDirectory()) { + await fs6.writeFile(file, ""); + } else { + await fs6.readdir(dir); + } + } + function createFileSync(file) { + let stats; + try { + stats = fs6.statSync(file); + } catch { + } + if (stats && stats.isFile()) + return; + const dir = path10.dirname(file); + try { + if (!fs6.statSync(dir).isDirectory()) { + fs6.readdirSync(dir); + } + } catch (err) { + if (err && err.code === "ENOENT") + mkdir.mkdirsSync(dir); + else + throw err; + } + fs6.writeFileSync(file, ""); + } + module.exports = { + createFile: u(createFile), + createFileSync + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/ensure/link.js +var require_link = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/ensure/link.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var u = require_universalify().fromPromise; + var path10 = __require("path"); + var fs6 = require_fs(); + var mkdir = require_mkdirs(); + var { pathExists } = require_path_exists(); + var { areIdentical } = require_stat(); + async function createLink(srcpath, dstpath) { + let dstStat; + try { + dstStat = await fs6.lstat(dstpath); + } catch { + } + let srcStat; + try { + srcStat = await fs6.lstat(srcpath); + } catch (err) { + err.message = err.message.replace("lstat", "ensureLink"); + throw err; + } + if (dstStat && areIdentical(srcStat, dstStat)) + return; + const dir = path10.dirname(dstpath); + const dirExists = await pathExists(dir); + if (!dirExists) { + await mkdir.mkdirs(dir); + } + await fs6.link(srcpath, dstpath); + } + function createLinkSync(srcpath, dstpath) { + let dstStat; + try { + dstStat = fs6.lstatSync(dstpath); + } catch { + } + try { + const srcStat = fs6.lstatSync(srcpath); + if (dstStat && areIdentical(srcStat, dstStat)) + return; + } catch (err) { + err.message = err.message.replace("lstat", "ensureLink"); + throw err; + } + const dir = path10.dirname(dstpath); + const dirExists = fs6.existsSync(dir); + if (dirExists) + return fs6.linkSync(srcpath, dstpath); + mkdir.mkdirsSync(dir); + return fs6.linkSync(srcpath, dstpath); + } + module.exports = { + createLink: u(createLink), + createLinkSync + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/ensure/symlink-paths.js +var require_symlink_paths = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var path10 = __require("path"); + var fs6 = require_fs(); + var { pathExists } = require_path_exists(); + var u = require_universalify().fromPromise; + async function symlinkPaths(srcpath, dstpath) { + if (path10.isAbsolute(srcpath)) { + try { + await fs6.lstat(srcpath); + } catch (err) { + err.message = err.message.replace("lstat", "ensureSymlink"); + throw err; + } + return { + toCwd: srcpath, + toDst: srcpath + }; + } + const dstdir = path10.dirname(dstpath); + const relativeToDst = path10.join(dstdir, srcpath); + const exists = await pathExists(relativeToDst); + if (exists) { + return { + toCwd: relativeToDst, + toDst: srcpath + }; + } + try { + await fs6.lstat(srcpath); + } catch (err) { + err.message = err.message.replace("lstat", "ensureSymlink"); + throw err; + } + return { + toCwd: srcpath, + toDst: path10.relative(dstdir, srcpath) + }; + } + function symlinkPathsSync(srcpath, dstpath) { + if (path10.isAbsolute(srcpath)) { + const exists2 = fs6.existsSync(srcpath); + if (!exists2) + throw new Error("absolute srcpath does not exist"); + return { + toCwd: srcpath, + toDst: srcpath + }; + } + const dstdir = path10.dirname(dstpath); + const relativeToDst = path10.join(dstdir, srcpath); + const exists = fs6.existsSync(relativeToDst); + if (exists) { + return { + toCwd: relativeToDst, + toDst: srcpath + }; + } + const srcExists = fs6.existsSync(srcpath); + if (!srcExists) + throw new Error("relative srcpath does not exist"); + return { + toCwd: srcpath, + toDst: path10.relative(dstdir, srcpath) + }; + } + module.exports = { + symlinkPaths: u(symlinkPaths), + symlinkPathsSync + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/ensure/symlink-type.js +var require_symlink_type = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var fs6 = require_fs(); + var u = require_universalify().fromPromise; + async function symlinkType(srcpath, type) { + if (type) + return type; + let stats; + try { + stats = await fs6.lstat(srcpath); + } catch { + return "file"; + } + return stats && stats.isDirectory() ? "dir" : "file"; + } + function symlinkTypeSync(srcpath, type) { + if (type) + return type; + let stats; + try { + stats = fs6.lstatSync(srcpath); + } catch { + return "file"; + } + return stats && stats.isDirectory() ? "dir" : "file"; + } + module.exports = { + symlinkType: u(symlinkType), + symlinkTypeSync + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/ensure/symlink.js +var require_symlink = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var u = require_universalify().fromPromise; + var path10 = __require("path"); + var fs6 = require_fs(); + var { mkdirs, mkdirsSync } = require_mkdirs(); + var { symlinkPaths, symlinkPathsSync } = require_symlink_paths(); + var { symlinkType, symlinkTypeSync } = require_symlink_type(); + var { pathExists } = require_path_exists(); + var { areIdentical } = require_stat(); + async function createSymlink(srcpath, dstpath, type) { + let stats; + try { + stats = await fs6.lstat(dstpath); + } catch { + } + if (stats && stats.isSymbolicLink()) { + const [srcStat, dstStat] = await Promise.all([ + fs6.stat(srcpath), + fs6.stat(dstpath) + ]); + if (areIdentical(srcStat, dstStat)) + return; + } + const relative2 = await symlinkPaths(srcpath, dstpath); + srcpath = relative2.toDst; + const toType = await symlinkType(relative2.toCwd, type); + const dir = path10.dirname(dstpath); + if (!await pathExists(dir)) { + await mkdirs(dir); + } + return fs6.symlink(srcpath, dstpath, toType); + } + function createSymlinkSync(srcpath, dstpath, type) { + let stats; + try { + stats = fs6.lstatSync(dstpath); + } catch { + } + if (stats && stats.isSymbolicLink()) { + const srcStat = fs6.statSync(srcpath); + const dstStat = fs6.statSync(dstpath); + if (areIdentical(srcStat, dstStat)) + return; + } + const relative2 = symlinkPathsSync(srcpath, dstpath); + srcpath = relative2.toDst; + type = symlinkTypeSync(relative2.toCwd, type); + const dir = path10.dirname(dstpath); + const exists = fs6.existsSync(dir); + if (exists) + return fs6.symlinkSync(srcpath, dstpath, type); + mkdirsSync(dir); + return fs6.symlinkSync(srcpath, dstpath, type); + } + module.exports = { + createSymlink: u(createSymlink), + createSymlinkSync + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/ensure/index.js +var require_ensure = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/ensure/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { createFile, createFileSync } = require_file(); + var { createLink, createLinkSync } = require_link(); + var { createSymlink, createSymlinkSync } = require_symlink(); + module.exports = { + // file + createFile, + createFileSync, + ensureFile: createFile, + ensureFileSync: createFileSync, + // link + createLink, + createLinkSync, + ensureLink: createLink, + ensureLinkSync: createLinkSync, + // symlink + createSymlink, + createSymlinkSync, + ensureSymlink: createSymlink, + ensureSymlinkSync: createSymlinkSync + }; + } +}); + +// ../testeranto/node_modules/jsonfile/utils.js +var require_utils4 = __commonJS({ + "../testeranto/node_modules/jsonfile/utils.js"(exports, module) { + init_cjs_shim(); + function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) { + const EOF = finalEOL ? EOL : ""; + const str = JSON.stringify(obj, replacer, spaces); + return str.replace(/\n/g, EOL) + EOF; + } + function stripBom(content) { + if (Buffer.isBuffer(content)) + content = content.toString("utf8"); + return content.replace(/^\uFEFF/, ""); + } + module.exports = { stringify, stripBom }; + } +}); + +// ../testeranto/node_modules/jsonfile/index.js +var require_jsonfile = __commonJS({ + "../testeranto/node_modules/jsonfile/index.js"(exports, module) { + init_cjs_shim(); + var _fs; + try { + _fs = require_graceful_fs(); + } catch (_) { + _fs = __require("fs"); + } + var universalify = require_universalify(); + var { stringify, stripBom } = require_utils4(); + async function _readFile(file, options = {}) { + if (typeof options === "string") { + options = { encoding: options }; + } + const fs6 = options.fs || _fs; + const shouldThrow = "throws" in options ? options.throws : true; + let data = await universalify.fromCallback(fs6.readFile)(file, options); + data = stripBom(data); + let obj; + try { + obj = JSON.parse(data, options ? options.reviver : null); + } catch (err) { + if (shouldThrow) { + err.message = `${file}: ${err.message}`; + throw err; + } else { + return null; + } + } + return obj; + } + var readFile = universalify.fromPromise(_readFile); + function readFileSync4(file, options = {}) { + if (typeof options === "string") { + options = { encoding: options }; + } + const fs6 = options.fs || _fs; + const shouldThrow = "throws" in options ? options.throws : true; + try { + let content = fs6.readFileSync(file, options); + content = stripBom(content); + return JSON.parse(content, options.reviver); + } catch (err) { + if (shouldThrow) { + err.message = `${file}: ${err.message}`; + throw err; + } else { + return null; + } + } + } + async function _writeFile(file, obj, options = {}) { + const fs6 = options.fs || _fs; + const str = stringify(obj, options); + await universalify.fromCallback(fs6.writeFile)(file, str, options); + } + var writeFile2 = universalify.fromPromise(_writeFile); + function writeFileSync(file, obj, options = {}) { + const fs6 = options.fs || _fs; + const str = stringify(obj, options); + return fs6.writeFileSync(file, str, options); + } + var jsonfile = { + readFile, + readFileSync: readFileSync4, + writeFile: writeFile2, + writeFileSync + }; + module.exports = jsonfile; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/json/jsonfile.js +var require_jsonfile2 = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/json/jsonfile.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var jsonFile = require_jsonfile(); + module.exports = { + // jsonfile exports + readJson: jsonFile.readFile, + readJsonSync: jsonFile.readFileSync, + writeJson: jsonFile.writeFile, + writeJsonSync: jsonFile.writeFileSync + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/output-file/index.js +var require_output_file = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/output-file/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var u = require_universalify().fromPromise; + var fs6 = require_fs(); + var path10 = __require("path"); + var mkdir = require_mkdirs(); + var pathExists = require_path_exists().pathExists; + async function outputFile(file, data, encoding = "utf-8") { + const dir = path10.dirname(file); + if (!await pathExists(dir)) { + await mkdir.mkdirs(dir); + } + return fs6.writeFile(file, data, encoding); + } + function outputFileSync(file, ...args) { + const dir = path10.dirname(file); + if (!fs6.existsSync(dir)) { + mkdir.mkdirsSync(dir); + } + fs6.writeFileSync(file, ...args); + } + module.exports = { + outputFile: u(outputFile), + outputFileSync + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/json/output-json.js +var require_output_json = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/json/output-json.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { stringify } = require_utils4(); + var { outputFile } = require_output_file(); + async function outputJson(file, data, options = {}) { + const str = stringify(data, options); + await outputFile(file, str, options); + } + module.exports = outputJson; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/json/output-json-sync.js +var require_output_json_sync = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { stringify } = require_utils4(); + var { outputFileSync } = require_output_file(); + function outputJsonSync(file, data, options) { + const str = stringify(data, options); + outputFileSync(file, str, options); + } + module.exports = outputJsonSync; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/json/index.js +var require_json = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/json/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var u = require_universalify().fromPromise; + var jsonFile = require_jsonfile2(); + jsonFile.outputJson = u(require_output_json()); + jsonFile.outputJsonSync = require_output_json_sync(); + jsonFile.outputJSON = jsonFile.outputJson; + jsonFile.outputJSONSync = jsonFile.outputJsonSync; + jsonFile.writeJSON = jsonFile.writeJson; + jsonFile.writeJSONSync = jsonFile.writeJsonSync; + jsonFile.readJSON = jsonFile.readJson; + jsonFile.readJSONSync = jsonFile.readJsonSync; + module.exports = jsonFile; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/move/move.js +var require_move = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/move/move.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var fs6 = require_fs(); + var path10 = __require("path"); + var { copy } = require_copy2(); + var { remove } = require_remove(); + var { mkdirp } = require_mkdirs(); + var { pathExists } = require_path_exists(); + var stat = require_stat(); + async function move(src, dest, opts = {}) { + const overwrite = opts.overwrite || opts.clobber || false; + const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts); + await stat.checkParentPaths(src, srcStat, dest, "move"); + const destParent = path10.dirname(dest); + const parsedParentPath = path10.parse(destParent); + if (parsedParentPath.root !== destParent) { + await mkdirp(destParent); + } + return doRename(src, dest, overwrite, isChangingCase); + } + async function doRename(src, dest, overwrite, isChangingCase) { + if (!isChangingCase) { + if (overwrite) { + await remove(dest); + } else if (await pathExists(dest)) { + throw new Error("dest already exists."); + } + } + try { + await fs6.rename(src, dest); + } catch (err) { + if (err.code !== "EXDEV") { + throw err; + } + await moveAcrossDevice(src, dest, overwrite); + } + } + async function moveAcrossDevice(src, dest, overwrite) { + const opts = { + overwrite, + errorOnExist: true, + preserveTimestamps: true + }; + await copy(src, dest, opts); + return remove(src); + } + module.exports = move; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/move/move-sync.js +var require_move_sync = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var fs6 = require_graceful_fs(); + var path10 = __require("path"); + var copySync = require_copy2().copySync; + var removeSync = require_remove().removeSync; + var mkdirpSync = require_mkdirs().mkdirpSync; + var stat = require_stat(); + function moveSync(src, dest, opts) { + opts = opts || {}; + const overwrite = opts.overwrite || opts.clobber || false; + const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts); + stat.checkParentPathsSync(src, srcStat, dest, "move"); + if (!isParentRoot(dest)) + mkdirpSync(path10.dirname(dest)); + return doRename(src, dest, overwrite, isChangingCase); + } + function isParentRoot(dest) { + const parent = path10.dirname(dest); + const parsedPath = path10.parse(parent); + return parsedPath.root === parent; + } + function doRename(src, dest, overwrite, isChangingCase) { + if (isChangingCase) + return rename2(src, dest, overwrite); + if (overwrite) { + removeSync(dest); + return rename2(src, dest, overwrite); + } + if (fs6.existsSync(dest)) + throw new Error("dest already exists."); + return rename2(src, dest, overwrite); + } + function rename2(src, dest, overwrite) { + try { + fs6.renameSync(src, dest); + } catch (err) { + if (err.code !== "EXDEV") + throw err; + return moveAcrossDevice(src, dest, overwrite); + } + } + function moveAcrossDevice(src, dest, overwrite) { + const opts = { + overwrite, + errorOnExist: true, + preserveTimestamps: true + }; + copySync(src, dest, opts); + return removeSync(src); + } + module.exports = moveSync; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/move/index.js +var require_move2 = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/move/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var u = require_universalify().fromPromise; + module.exports = { + move: u(require_move()), + moveSync: require_move_sync() + }; + } +}); + +// ../testeranto/node_modules/fs-extra/lib/index.js +var require_lib = __commonJS({ + "../testeranto/node_modules/fs-extra/lib/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + module.exports = { + // Export promiseified graceful-fs: + ...require_fs(), + // Export extra methods: + ...require_copy2(), + ...require_empty(), + ...require_ensure(), + ...require_json(), + ...require_mkdirs(), + ...require_move2(), + ...require_output_file(), + ...require_path_exists(), + ...require_remove() + }; + } +}); + +// ../testeranto/node_modules/get-uri/dist/notfound.js +var require_notfound = __commonJS({ + "../testeranto/node_modules/get-uri/dist/notfound.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var NotFoundError = class extends Error { + constructor(message) { + super(message || "File does not exist at the specified endpoint"); + this.code = "ENOTFOUND"; + } + }; + exports.default = NotFoundError; + } +}); + +// ../testeranto/node_modules/get-uri/dist/file.js +var require_file2 = __commonJS({ + "../testeranto/node_modules/get-uri/dist/file.js"(exports) { + "use strict"; + init_cjs_shim(); + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.file = void 0; + var debug_1 = __importDefault2(require_src()); + var fs_1 = __require("fs"); + var fs_extra_1 = require_lib(); + var notfound_1 = __importDefault2(require_notfound()); + var notmodified_1 = __importDefault2(require_notmodified()); + var url_1 = __require("url"); + var debug5 = (0, debug_1.default)("get-uri:file"); + var file = async ({ href: uri }, opts = {}) => { + const { + cache, + flags = "r", + mode = 438 + // =0666 + } = opts; + try { + const filepath = (0, url_1.fileURLToPath)(uri); + debug5("Normalized pathname: %o", filepath); + const fd = await (0, fs_extra_1.open)(filepath, flags, mode); + const stat = await (0, fs_extra_1.fstat)(fd); + if (cache && cache.stat && stat && isNotModified(cache.stat, stat)) { + throw new notmodified_1.default(); + } + const rs = (0, fs_1.createReadStream)(null, { + autoClose: true, + ...opts, + fd + }); + rs.stat = stat; + return rs; + } catch (err) { + if (err.code === "ENOENT") { + throw new notfound_1.default(); + } + throw err; + } + }; + exports.file = file; + function isNotModified(prev, curr) { + return +prev.mtime === +curr.mtime; + } + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/parseControlResponse.js +var require_parseControlResponse = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/parseControlResponse.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.positiveIntermediate = exports.positiveCompletion = exports.isMultiline = exports.isSingleLine = exports.parseControlResponse = void 0; + var LF = "\n"; + function parseControlResponse(text) { + const lines = text.split(/\r?\n/).filter(isNotBlank); + const messages = []; + let startAt = 0; + let tokenRegex; + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + if (!tokenRegex) { + if (isMultiline(line)) { + const token = line.substr(0, 3); + tokenRegex = new RegExp(`^${token}(?:$| )`); + startAt = i; + } else if (isSingleLine(line)) { + messages.push(line); + } + } else if (tokenRegex.test(line)) { + tokenRegex = void 0; + messages.push(lines.slice(startAt, i + 1).join(LF)); + } + } + const rest = tokenRegex ? lines.slice(startAt).join(LF) + LF : ""; + return { messages, rest }; + } + exports.parseControlResponse = parseControlResponse; + function isSingleLine(line) { + return /^\d\d\d(?:$| )/.test(line); + } + exports.isSingleLine = isSingleLine; + function isMultiline(line) { + return /^\d\d\d-/.test(line); + } + exports.isMultiline = isMultiline; + function positiveCompletion(code) { + return code >= 200 && code < 300; + } + exports.positiveCompletion = positiveCompletion; + function positiveIntermediate(code) { + return code >= 300 && code < 400; + } + exports.positiveIntermediate = positiveIntermediate; + function isNotBlank(str) { + return str.trim() !== ""; + } + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/FtpContext.js +var require_FtpContext = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/FtpContext.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.FTPContext = exports.FTPError = void 0; + var net_1 = __require("net"); + var parseControlResponse_1 = require_parseControlResponse(); + var FTPError = class extends Error { + constructor(res) { + super(res.message); + this.name = this.constructor.name; + this.code = res.code; + } + }; + exports.FTPError = FTPError; + function doNothing() { + } + var FTPContext = class { + /** + * Instantiate an FTP context. + * + * @param timeout - Timeout in milliseconds to apply to control and data connections. Use 0 for no timeout. + * @param encoding - Encoding to use for control connection. UTF-8 by default. Use "latin1" for older servers. + */ + constructor(timeout2 = 0, encoding = "utf8") { + this.timeout = timeout2; + this.verbose = false; + this.ipFamily = void 0; + this.tlsOptions = {}; + this._partialResponse = ""; + this._encoding = encoding; + this._socket = this.socket = this._newSocket(); + this._dataSocket = void 0; + } + /** + * Close the context. + */ + close() { + const message = this._task ? "User closed client during task" : "User closed client"; + const err = new Error(message); + this.closeWithError(err); + } + /** + * Close the context with an error. + */ + closeWithError(err) { + if (this._closingError) { + return; + } + this._closingError = err; + this._closeControlSocket(); + this._closeSocket(this._dataSocket); + this._passToHandler(err); + this._stopTrackingTask(); + } + /** + * Returns true if this context has been closed or hasn't been connected yet. You can reopen it with `access`. + */ + get closed() { + return this.socket.remoteAddress === void 0 || this._closingError !== void 0; + } + /** + * Reset this contex and all of its state. + */ + reset() { + this.socket = this._newSocket(); + } + /** + * Get the FTP control socket. + */ + get socket() { + return this._socket; + } + /** + * Set the socket for the control connection. This will only close the current control socket + * if the new one is not an upgrade to the current one. + */ + set socket(socket) { + this.dataSocket = void 0; + this.tlsOptions = {}; + this._partialResponse = ""; + if (this._socket) { + const newSocketUpgradesExisting = socket.localPort === this._socket.localPort; + if (newSocketUpgradesExisting) { + this._removeSocketListeners(this.socket); + } else { + this._closeControlSocket(); + } + } + if (socket) { + this._closingError = void 0; + socket.setTimeout(0); + socket.setEncoding(this._encoding); + socket.setKeepAlive(true); + socket.on("data", (data) => this._onControlSocketData(data)); + socket.on("end", () => this.closeWithError(new Error("Server sent FIN packet unexpectedly, closing connection."))); + socket.on("close", (hadError) => { + if (!hadError) + this.closeWithError(new Error("Server closed connection unexpectedly.")); + }); + this._setupDefaultErrorHandlers(socket, "control socket"); + } + this._socket = socket; + } + /** + * Get the current FTP data connection if present. + */ + get dataSocket() { + return this._dataSocket; + } + /** + * Set the socket for the data connection. This will automatically close the former data socket. + */ + set dataSocket(socket) { + this._closeSocket(this._dataSocket); + if (socket) { + socket.setTimeout(0); + this._setupDefaultErrorHandlers(socket, "data socket"); + } + this._dataSocket = socket; + } + /** + * Get the currently used encoding. + */ + get encoding() { + return this._encoding; + } + /** + * Set the encoding used for the control socket. + * + * See https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings for what encodings + * are supported by Node. + */ + set encoding(encoding) { + this._encoding = encoding; + if (this.socket) { + this.socket.setEncoding(encoding); + } + } + /** + * Send an FTP command without waiting for or handling the result. + */ + send(command2) { + const containsPassword = command2.startsWith("PASS"); + const message = containsPassword ? "> PASS ###" : `> ${command2}`; + this.log(message); + this._socket.write(command2 + "\r\n", this.encoding); + } + /** + * Send an FTP command and handle the first response. Use this if you have a simple + * request-response situation. + */ + request(command2) { + return this.handle(command2, (res, task) => { + if (res instanceof Error) { + task.reject(res); + } else { + task.resolve(res); + } + }); + } + /** + * Send an FTP command and handle any response until you resolve/reject. Use this if you expect multiple responses + * to a request. This returns a Promise that will hold whatever the response handler passed on when resolving/rejecting its task. + */ + handle(command2, responseHandler) { + if (this._task) { + const err = new Error("User launched a task while another one is still running. Forgot to use 'await' or '.then()'?"); + err.stack += ` +Running task launched at: ${this._task.stack}`; + this.closeWithError(err); + } + return new Promise((resolveTask, rejectTask) => { + this._task = { + stack: new Error().stack || "Unknown call stack", + responseHandler, + resolver: { + resolve: (arg) => { + this._stopTrackingTask(); + resolveTask(arg); + }, + reject: (err) => { + this._stopTrackingTask(); + rejectTask(err); + } + } + }; + if (this._closingError) { + const err = new Error(`Client is closed because ${this._closingError.message}`); + err.stack += ` +Closing reason: ${this._closingError.stack}`; + err.code = this._closingError.code !== void 0 ? this._closingError.code : "0"; + this._passToHandler(err); + return; + } + this.socket.setTimeout(this.timeout); + if (command2) { + this.send(command2); + } + }); + } + /** + * Log message if set to be verbose. + */ + log(message) { + if (this.verbose) { + console.log(message); + } + } + /** + * Return true if the control socket is using TLS. This does not mean that a session + * has already been negotiated. + */ + get hasTLS() { + return "encrypted" in this._socket; + } + /** + * Removes reference to current task and handler. This won't resolve or reject the task. + * @protected + */ + _stopTrackingTask() { + this.socket.setTimeout(0); + this._task = void 0; + } + /** + * Handle incoming data on the control socket. The chunk is going to be of type `string` + * because we let `socket` handle encoding with `setEncoding`. + * @protected + */ + _onControlSocketData(chunk) { + this.log(`< ${chunk}`); + const completeResponse = this._partialResponse + chunk; + const parsed = (0, parseControlResponse_1.parseControlResponse)(completeResponse); + this._partialResponse = parsed.rest; + for (const message of parsed.messages) { + const code = parseInt(message.substr(0, 3), 10); + const response = { code, message }; + const err = code >= 400 ? new FTPError(response) : void 0; + this._passToHandler(err ? err : response); + } + } + /** + * Send the current handler a response. This is usually a control socket response + * or a socket event, like an error or timeout. + * @protected + */ + _passToHandler(response) { + if (this._task) { + this._task.responseHandler(response, this._task.resolver); + } + } + /** + * Setup all error handlers for a socket. + * @protected + */ + _setupDefaultErrorHandlers(socket, identifier) { + socket.once("error", (error) => { + error.message += ` (${identifier})`; + this.closeWithError(error); + }); + socket.once("close", (hadError) => { + if (hadError) { + this.closeWithError(new Error(`Socket closed due to transmission error (${identifier})`)); + } + }); + socket.once("timeout", () => { + socket.destroy(); + this.closeWithError(new Error(`Timeout (${identifier})`)); + }); + } + /** + * Close the control socket. Sends QUIT, then FIN, and ignores any response or error. + */ + _closeControlSocket() { + this._removeSocketListeners(this._socket); + this._socket.on("error", doNothing); + this.send("QUIT"); + this._closeSocket(this._socket); + } + /** + * Close a socket, ignores any error. + * @protected + */ + _closeSocket(socket) { + if (socket) { + this._removeSocketListeners(socket); + socket.on("error", doNothing); + socket.destroy(); + } + } + /** + * Remove all default listeners for socket. + * @protected + */ + _removeSocketListeners(socket) { + socket.removeAllListeners(); + socket.removeAllListeners("timeout"); + socket.removeAllListeners("data"); + socket.removeAllListeners("end"); + socket.removeAllListeners("error"); + socket.removeAllListeners("close"); + socket.removeAllListeners("connect"); + } + /** + * Provide a new socket instance. + * + * Internal use only, replaced for unit tests. + */ + _newSocket() { + return new net_1.Socket(); + } + }; + exports.FTPContext = FTPContext; + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/FileInfo.js +var require_FileInfo = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/FileInfo.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.FileInfo = exports.FileType = void 0; + var FileType; + (function(FileType2) { + FileType2[FileType2["Unknown"] = 0] = "Unknown"; + FileType2[FileType2["File"] = 1] = "File"; + FileType2[FileType2["Directory"] = 2] = "Directory"; + FileType2[FileType2["SymbolicLink"] = 3] = "SymbolicLink"; + })(FileType || (exports.FileType = FileType = {})); + var FileInfo = class { + constructor(name) { + this.name = name; + this.type = FileType.Unknown; + this.size = 0; + this.rawModifiedAt = ""; + this.modifiedAt = void 0; + this.permissions = void 0; + this.hardLinkCount = void 0; + this.link = void 0; + this.group = void 0; + this.user = void 0; + this.uniqueID = void 0; + this.name = name; + } + get isDirectory() { + return this.type === FileType.Directory; + } + get isSymbolicLink() { + return this.type === FileType.SymbolicLink; + } + get isFile() { + return this.type === FileType.File; + } + /** + * Deprecated, legacy API. Use `rawModifiedAt` instead. + * @deprecated + */ + get date() { + return this.rawModifiedAt; + } + set date(rawModifiedAt) { + this.rawModifiedAt = rawModifiedAt; + } + }; + exports.FileInfo = FileInfo; + FileInfo.UnixPermission = { + Read: 4, + Write: 2, + Execute: 1 + }; + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/parseListDOS.js +var require_parseListDOS = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/parseListDOS.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.transformList = exports.parseLine = exports.testLine = void 0; + var FileInfo_1 = require_FileInfo(); + var RE_LINE = new RegExp( + "(\\S+)\\s+(\\S+)\\s+(?:()|([0-9]+))\\s+(\\S.*)" + // First non-space followed by rest of line (name) + ); + function testLine(line) { + return /^\d{2}/.test(line) && RE_LINE.test(line); + } + exports.testLine = testLine; + function parseLine(line) { + const groups = line.match(RE_LINE); + if (groups === null) { + return void 0; + } + const name = groups[5]; + if (name === "." || name === "..") { + return void 0; + } + const file = new FileInfo_1.FileInfo(name); + const fileType = groups[3]; + if (fileType === "") { + file.type = FileInfo_1.FileType.Directory; + file.size = 0; + } else { + file.type = FileInfo_1.FileType.File; + file.size = parseInt(groups[4], 10); + } + file.rawModifiedAt = groups[1] + " " + groups[2]; + return file; + } + exports.parseLine = parseLine; + function transformList(files) { + return files; + } + exports.transformList = transformList; + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/parseListUnix.js +var require_parseListUnix = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/parseListUnix.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.transformList = exports.parseLine = exports.testLine = void 0; + var FileInfo_1 = require_FileInfo(); + var JA_MONTH = "\u6708"; + var JA_DAY = "\u65E5"; + var JA_YEAR = "\u5E74"; + var RE_LINE = new RegExp("([bcdelfmpSs-])(((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-]?)))\\+?\\s*(\\d+)\\s+(?:(\\S+(?:\\s\\S+)*?)\\s+)?(?:(\\S+(?:\\s\\S+)*)\\s+)?(\\d+(?:,\\s*\\d+)?)\\s+((?:\\d+[-/]\\d+[-/]\\d+)|(?:\\S{3}\\s+\\d{1,2})|(?:\\d{1,2}\\s+\\S{3})|(?:\\d{1,2}" + JA_MONTH + "\\s+\\d{1,2}" + JA_DAY + "))\\s+((?:\\d+(?::\\d+)?)|(?:\\d{4}" + JA_YEAR + "))\\s(.*)"); + function testLine(line) { + return RE_LINE.test(line); + } + exports.testLine = testLine; + function parseLine(line) { + const groups = line.match(RE_LINE); + if (groups === null) { + return void 0; + } + const name = groups[21]; + if (name === "." || name === "..") { + return void 0; + } + const file = new FileInfo_1.FileInfo(name); + file.size = parseInt(groups[18], 10); + file.user = groups[16]; + file.group = groups[17]; + file.hardLinkCount = parseInt(groups[15], 10); + file.rawModifiedAt = groups[19] + " " + groups[20]; + file.permissions = { + user: parseMode(groups[4], groups[5], groups[6]), + group: parseMode(groups[8], groups[9], groups[10]), + world: parseMode(groups[12], groups[13], groups[14]) + }; + switch (groups[1].charAt(0)) { + case "d": + file.type = FileInfo_1.FileType.Directory; + break; + case "e": + file.type = FileInfo_1.FileType.SymbolicLink; + break; + case "l": + file.type = FileInfo_1.FileType.SymbolicLink; + break; + case "b": + case "c": + file.type = FileInfo_1.FileType.File; + break; + case "f": + case "-": + file.type = FileInfo_1.FileType.File; + break; + default: + file.type = FileInfo_1.FileType.Unknown; + } + if (file.isSymbolicLink) { + const end = name.indexOf(" -> "); + if (end !== -1) { + file.name = name.substring(0, end); + file.link = name.substring(end + 4); + } + } + return file; + } + exports.parseLine = parseLine; + function transformList(files) { + return files; + } + exports.transformList = transformList; + function parseMode(r, w, x) { + let value = 0; + if (r !== "-") { + value += FileInfo_1.FileInfo.UnixPermission.Read; + } + if (w !== "-") { + value += FileInfo_1.FileInfo.UnixPermission.Write; + } + const execToken = x.charAt(0); + if (execToken !== "-" && execToken.toUpperCase() !== execToken) { + value += FileInfo_1.FileInfo.UnixPermission.Execute; + } + return value; + } + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/parseListMLSD.js +var require_parseListMLSD = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/parseListMLSD.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.parseMLSxDate = exports.transformList = exports.parseLine = exports.testLine = void 0; + var FileInfo_1 = require_FileInfo(); + function parseSize(value, info) { + info.size = parseInt(value, 10); + } + var factHandlersByName = { + "size": parseSize, + // File size + "sizd": parseSize, + // Directory size + "unique": (value, info) => { + info.uniqueID = value; + }, + "modify": (value, info) => { + info.modifiedAt = parseMLSxDate(value); + info.rawModifiedAt = info.modifiedAt.toISOString(); + }, + "type": (value, info) => { + if (value.startsWith("OS.unix=slink")) { + info.type = FileInfo_1.FileType.SymbolicLink; + info.link = value.substr(value.indexOf(":") + 1); + return 1; + } + switch (value) { + case "file": + info.type = FileInfo_1.FileType.File; + break; + case "dir": + info.type = FileInfo_1.FileType.Directory; + break; + case "OS.unix=symlink": + info.type = FileInfo_1.FileType.SymbolicLink; + break; + case "cdir": + case "pdir": + return 2; + default: + info.type = FileInfo_1.FileType.Unknown; + } + return 1; + }, + "unix.mode": (value, info) => { + const digits = value.substr(-3); + info.permissions = { + user: parseInt(digits[0], 10), + group: parseInt(digits[1], 10), + world: parseInt(digits[2], 10) + }; + }, + "unix.ownername": (value, info) => { + info.user = value; + }, + "unix.owner": (value, info) => { + if (info.user === void 0) + info.user = value; + }, + get "unix.uid"() { + return this["unix.owner"]; + }, + "unix.groupname": (value, info) => { + info.group = value; + }, + "unix.group": (value, info) => { + if (info.group === void 0) + info.group = value; + }, + get "unix.gid"() { + return this["unix.group"]; + } + // Regarding the fact "perm": + // We don't handle permission information stored in "perm" because its information is conceptually + // different from what users of FTP clients usually associate with "permissions". Those that have + // some expectations (and probably want to edit them with a SITE command) often unknowingly expect + // the Unix permission system. The information passed by "perm" describes what FTP commands can be + // executed with a file/directory. But even this can be either incomplete or just meant as a "guide" + // as the spec mentions. From https://tools.ietf.org/html/rfc3659#section-7.5.5: "The permissions are + // described here as they apply to FTP commands. They may not map easily into particular permissions + // available on the server's operating system." The parser by Apache Commons tries to translate these + // to Unix permissions – this is misleading users and might not even be correct. + }; + function splitStringOnce(str, delimiter) { + const pos = str.indexOf(delimiter); + const a = str.substr(0, pos); + const b = str.substr(pos + delimiter.length); + return [a, b]; + } + function testLine(line) { + return /^\S+=\S+;/.test(line) || line.startsWith(" "); + } + exports.testLine = testLine; + function parseLine(line) { + const [packedFacts, name] = splitStringOnce(line, " "); + if (name === "" || name === "." || name === "..") { + return void 0; + } + const info = new FileInfo_1.FileInfo(name); + const facts = packedFacts.split(";"); + for (const fact of facts) { + const [factName, factValue] = splitStringOnce(fact, "="); + if (!factValue) { + continue; + } + const factHandler = factHandlersByName[factName.toLowerCase()]; + if (!factHandler) { + continue; + } + const result = factHandler(factValue, info); + if (result === 2) { + return void 0; + } + } + return info; + } + exports.parseLine = parseLine; + function transformList(files) { + const nonLinksByID = /* @__PURE__ */ new Map(); + for (const file of files) { + if (!file.isSymbolicLink && file.uniqueID !== void 0) { + nonLinksByID.set(file.uniqueID, file); + } + } + const resolvedFiles = []; + for (const file of files) { + if (file.isSymbolicLink && file.uniqueID !== void 0 && file.link === void 0) { + const target = nonLinksByID.get(file.uniqueID); + if (target !== void 0) { + file.link = target.name; + } + } + const isPartOfDirectory = !file.name.includes("/"); + if (isPartOfDirectory) { + resolvedFiles.push(file); + } + } + return resolvedFiles; + } + exports.transformList = transformList; + function parseMLSxDate(fact) { + return new Date(Date.UTC( + +fact.slice(0, 4), + // Year + +fact.slice(4, 6) - 1, + // Month + +fact.slice(6, 8), + // Date + +fact.slice(8, 10), + // Hours + +fact.slice(10, 12), + // Minutes + +fact.slice(12, 14), + // Seconds + +fact.slice(15, 18) + // Milliseconds + )); + } + exports.parseMLSxDate = parseMLSxDate; + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/parseList.js +var require_parseList = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/parseList.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.parseList = void 0; + var dosParser = __importStar2(require_parseListDOS()); + var unixParser = __importStar2(require_parseListUnix()); + var mlsdParser = __importStar2(require_parseListMLSD()); + var availableParsers = [ + dosParser, + unixParser, + mlsdParser + // Keep MLSD last, may accept filename only + ]; + function firstCompatibleParser(line, parsers) { + return parsers.find((parser2) => parser2.testLine(line) === true); + } + function isNotBlank(str) { + return str.trim() !== ""; + } + function isNotMeta(str) { + return !str.startsWith("total"); + } + var REGEX_NEWLINE = /\r?\n/; + function parseList(rawList) { + const lines = rawList.split(REGEX_NEWLINE).filter(isNotBlank).filter(isNotMeta); + if (lines.length === 0) { + return []; + } + const testLine = lines[lines.length - 1]; + const parser2 = firstCompatibleParser(testLine, availableParsers); + if (!parser2) { + throw new Error("This library only supports MLSD, Unix- or DOS-style directory listing. Your FTP server seems to be using another format. You can see the transmitted listing when setting `client.ftp.verbose = true`. You can then provide a custom parser to `client.parseList`, see the documentation for details."); + } + const files = lines.map(parser2.parseLine).filter((info) => info !== void 0); + return parser2.transformList(files); + } + exports.parseList = parseList; + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/ProgressTracker.js +var require_ProgressTracker = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/ProgressTracker.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProgressTracker = void 0; + var ProgressTracker = class { + constructor() { + this.bytesOverall = 0; + this.intervalMs = 500; + this.onStop = noop; + this.onHandle = noop; + } + /** + * Register a new handler for progress info. Use `undefined` to disable reporting. + */ + reportTo(onHandle = noop) { + this.onHandle = onHandle; + } + /** + * Start tracking transfer progress of a socket. + * + * @param socket The socket to observe. + * @param name A name associated with this progress tracking, e.g. a filename. + * @param type The type of the transfer, typically "upload" or "download". + */ + start(socket, name, type) { + let lastBytes = 0; + this.onStop = poll(this.intervalMs, () => { + const bytes = socket.bytesRead + socket.bytesWritten; + this.bytesOverall += bytes - lastBytes; + lastBytes = bytes; + this.onHandle({ + name, + type, + bytes, + bytesOverall: this.bytesOverall + }); + }); + } + /** + * Stop tracking transfer progress. + */ + stop() { + this.onStop(false); + } + /** + * Call the progress handler one more time, then stop tracking. + */ + updateAndStop() { + this.onStop(true); + } + }; + exports.ProgressTracker = ProgressTracker; + function poll(intervalMs, updateFunc) { + const id = setInterval(updateFunc, intervalMs); + const stopFunc = (stopWithUpdate) => { + clearInterval(id); + if (stopWithUpdate) { + updateFunc(); + } + updateFunc = noop; + }; + updateFunc(); + return stopFunc; + } + function noop() { + } + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/StringWriter.js +var require_StringWriter = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/StringWriter.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.StringWriter = void 0; + var stream_1 = __require("stream"); + var StringWriter = class extends stream_1.Writable { + constructor() { + super(...arguments); + this.buf = Buffer.alloc(0); + } + _write(chunk, _, callback) { + if (chunk instanceof Buffer) { + this.buf = Buffer.concat([this.buf, chunk]); + callback(null); + } else { + callback(new Error("StringWriter expects chunks of type 'Buffer'.")); + } + } + getText(encoding) { + return this.buf.toString(encoding); + } + }; + exports.StringWriter = StringWriter; + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/netUtils.js +var require_netUtils = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/netUtils.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ipIsPrivateV4Address = exports.upgradeSocket = exports.describeAddress = exports.describeTLS = void 0; + var tls_1 = __require("tls"); + function describeTLS(socket) { + if (socket instanceof tls_1.TLSSocket) { + const protocol = socket.getProtocol(); + return protocol ? protocol : "Server socket or disconnected client socket"; + } + return "No encryption"; + } + exports.describeTLS = describeTLS; + function describeAddress(socket) { + if (socket.remoteFamily === "IPv6") { + return `[${socket.remoteAddress}]:${socket.remotePort}`; + } + return `${socket.remoteAddress}:${socket.remotePort}`; + } + exports.describeAddress = describeAddress; + function upgradeSocket(socket, options) { + return new Promise((resolve5, reject) => { + const tlsOptions = Object.assign({}, options, { + socket + }); + const tlsSocket = (0, tls_1.connect)(tlsOptions, () => { + const expectCertificate = tlsOptions.rejectUnauthorized !== false; + if (expectCertificate && !tlsSocket.authorized) { + reject(tlsSocket.authorizationError); + } else { + tlsSocket.removeAllListeners("error"); + resolve5(tlsSocket); + } + }).once("error", (error) => { + reject(error); + }); + }); + } + exports.upgradeSocket = upgradeSocket; + function ipIsPrivateV4Address(ip = "") { + if (ip.startsWith("::ffff:")) { + ip = ip.substr(7); + } + const octets = ip.split(".").map((o) => parseInt(o, 10)); + return octets[0] === 10 || octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31 || octets[0] === 192 && octets[1] === 168 || ip === "127.0.0.1"; + } + exports.ipIsPrivateV4Address = ipIsPrivateV4Address; + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/transfer.js +var require_transfer = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/transfer.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.downloadTo = exports.uploadFrom = exports.connectForPassiveTransfer = exports.parsePasvResponse = exports.enterPassiveModeIPv4 = exports.parseEpsvResponse = exports.enterPassiveModeIPv6 = void 0; + var netUtils_1 = require_netUtils(); + var stream_1 = __require("stream"); + var tls_1 = __require("tls"); + var parseControlResponse_1 = require_parseControlResponse(); + async function enterPassiveModeIPv6(ftp) { + const res = await ftp.request("EPSV"); + const port = parseEpsvResponse(res.message); + if (!port) { + throw new Error("Can't parse EPSV response: " + res.message); + } + const controlHost = ftp.socket.remoteAddress; + if (controlHost === void 0) { + throw new Error("Control socket is disconnected, can't get remote address."); + } + await connectForPassiveTransfer(controlHost, port, ftp); + return res; + } + exports.enterPassiveModeIPv6 = enterPassiveModeIPv6; + function parseEpsvResponse(message) { + const groups = message.match(/[|!]{3}(.+)[|!]/); + if (groups === null || groups[1] === void 0) { + throw new Error(`Can't parse response to 'EPSV': ${message}`); + } + const port = parseInt(groups[1], 10); + if (Number.isNaN(port)) { + throw new Error(`Can't parse response to 'EPSV', port is not a number: ${message}`); + } + return port; + } + exports.parseEpsvResponse = parseEpsvResponse; + async function enterPassiveModeIPv4(ftp) { + const res = await ftp.request("PASV"); + const target = parsePasvResponse(res.message); + if (!target) { + throw new Error("Can't parse PASV response: " + res.message); + } + const controlHost = ftp.socket.remoteAddress; + if ((0, netUtils_1.ipIsPrivateV4Address)(target.host) && controlHost && !(0, netUtils_1.ipIsPrivateV4Address)(controlHost)) { + target.host = controlHost; + } + await connectForPassiveTransfer(target.host, target.port, ftp); + return res; + } + exports.enterPassiveModeIPv4 = enterPassiveModeIPv4; + function parsePasvResponse(message) { + const groups = message.match(/([-\d]+,[-\d]+,[-\d]+,[-\d]+),([-\d]+),([-\d]+)/); + if (groups === null || groups.length !== 4) { + throw new Error(`Can't parse response to 'PASV': ${message}`); + } + return { + host: groups[1].replace(/,/g, "."), + port: (parseInt(groups[2], 10) & 255) * 256 + (parseInt(groups[3], 10) & 255) + }; + } + exports.parsePasvResponse = parsePasvResponse; + function connectForPassiveTransfer(host, port, ftp) { + return new Promise((resolve5, reject) => { + let socket = ftp._newSocket(); + const handleConnErr = function(err) { + err.message = "Can't open data connection in passive mode: " + err.message; + reject(err); + }; + const handleTimeout = function() { + socket.destroy(); + reject(new Error(`Timeout when trying to open data connection to ${host}:${port}`)); + }; + socket.setTimeout(ftp.timeout); + socket.on("error", handleConnErr); + socket.on("timeout", handleTimeout); + socket.connect({ port, host, family: ftp.ipFamily }, () => { + if (ftp.socket instanceof tls_1.TLSSocket) { + socket = (0, tls_1.connect)(Object.assign({}, ftp.tlsOptions, { + socket, + // Reuse the TLS session negotiated earlier when the control connection + // was upgraded. Servers expect this because it provides additional + // security: If a completely new session would be negotiated, a hacker + // could guess the port and connect to the new data connection before we do + // by just starting his/her own TLS session. + session: ftp.socket.getSession() + })); + } + socket.removeListener("error", handleConnErr); + socket.removeListener("timeout", handleTimeout); + ftp.dataSocket = socket; + resolve5(); + }); + }); + } + exports.connectForPassiveTransfer = connectForPassiveTransfer; + var TransferResolver = class { + /** + * Instantiate a TransferResolver + */ + constructor(ftp, progress) { + this.ftp = ftp; + this.progress = progress; + this.response = void 0; + this.dataTransferDone = false; + } + /** + * Mark the beginning of a transfer. + * + * @param name - Name of the transfer, usually the filename. + * @param type - Type of transfer, usually "upload" or "download". + */ + onDataStart(name, type) { + if (this.ftp.dataSocket === void 0) { + throw new Error("Data transfer should start but there is no data connection."); + } + this.ftp.socket.setTimeout(0); + this.ftp.dataSocket.setTimeout(this.ftp.timeout); + this.progress.start(this.ftp.dataSocket, name, type); + } + /** + * The data connection has finished the transfer. + */ + onDataDone(task) { + this.progress.updateAndStop(); + this.ftp.socket.setTimeout(this.ftp.timeout); + if (this.ftp.dataSocket) { + this.ftp.dataSocket.setTimeout(0); + } + this.dataTransferDone = true; + this.tryResolve(task); + } + /** + * The control connection reports the transfer as finished. + */ + onControlDone(task, response) { + this.response = response; + this.tryResolve(task); + } + /** + * An error has been reported and the task should be rejected. + */ + onError(task, err) { + this.progress.updateAndStop(); + this.ftp.socket.setTimeout(this.ftp.timeout); + this.ftp.dataSocket = void 0; + task.reject(err); + } + /** + * Control connection sent an unexpected request requiring a response from our part. We + * can't provide that (because unknown) and have to close the contrext with an error because + * the FTP server is now caught up in a state we can't resolve. + */ + onUnexpectedRequest(response) { + const err = new Error(`Unexpected FTP response is requesting an answer: ${response.message}`); + this.ftp.closeWithError(err); + } + tryResolve(task) { + const canResolve = this.dataTransferDone && this.response !== void 0; + if (canResolve) { + this.ftp.dataSocket = void 0; + task.resolve(this.response); + } + } + }; + function uploadFrom(source, config2) { + const resolver = new TransferResolver(config2.ftp, config2.tracker); + const fullCommand = `${config2.command} ${config2.remotePath}`; + return config2.ftp.handle(fullCommand, (res, task) => { + if (res instanceof Error) { + resolver.onError(task, res); + } else if (res.code === 150 || res.code === 125) { + const dataSocket = config2.ftp.dataSocket; + if (!dataSocket) { + resolver.onError(task, new Error("Upload should begin but no data connection is available.")); + return; + } + const canUpload = "getCipher" in dataSocket ? dataSocket.getCipher() !== void 0 : true; + onConditionOrEvent(canUpload, dataSocket, "secureConnect", () => { + config2.ftp.log(`Uploading to ${(0, netUtils_1.describeAddress)(dataSocket)} (${(0, netUtils_1.describeTLS)(dataSocket)})`); + resolver.onDataStart(config2.remotePath, config2.type); + (0, stream_1.pipeline)(source, dataSocket, (err) => { + if (err) { + resolver.onError(task, err); + } else { + resolver.onDataDone(task); + } + }); + }); + } else if ((0, parseControlResponse_1.positiveCompletion)(res.code)) { + resolver.onControlDone(task, res); + } else if ((0, parseControlResponse_1.positiveIntermediate)(res.code)) { + resolver.onUnexpectedRequest(res); + } + }); + } + exports.uploadFrom = uploadFrom; + function downloadTo(destination, config2) { + if (!config2.ftp.dataSocket) { + throw new Error("Download will be initiated but no data connection is available."); + } + const resolver = new TransferResolver(config2.ftp, config2.tracker); + return config2.ftp.handle(config2.command, (res, task) => { + if (res instanceof Error) { + resolver.onError(task, res); + } else if (res.code === 150 || res.code === 125) { + const dataSocket = config2.ftp.dataSocket; + if (!dataSocket) { + resolver.onError(task, new Error("Download should begin but no data connection is available.")); + return; + } + config2.ftp.log(`Downloading from ${(0, netUtils_1.describeAddress)(dataSocket)} (${(0, netUtils_1.describeTLS)(dataSocket)})`); + resolver.onDataStart(config2.remotePath, config2.type); + (0, stream_1.pipeline)(dataSocket, destination, (err) => { + if (err) { + resolver.onError(task, err); + } else { + resolver.onDataDone(task); + } + }); + } else if (res.code === 350) { + config2.ftp.send("RETR " + config2.remotePath); + } else if ((0, parseControlResponse_1.positiveCompletion)(res.code)) { + resolver.onControlDone(task, res); + } else if ((0, parseControlResponse_1.positiveIntermediate)(res.code)) { + resolver.onUnexpectedRequest(res); + } + }); + } + exports.downloadTo = downloadTo; + function onConditionOrEvent(condition, emitter, eventName, action) { + if (condition === true) { + action(); + } else { + emitter.once(eventName, () => action()); + } + } + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/Client.js +var require_Client = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/Client.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Client = void 0; + var fs_1 = __require("fs"); + var path_1 = __require("path"); + var tls_1 = __require("tls"); + var util_1 = __require("util"); + var FtpContext_1 = require_FtpContext(); + var parseList_1 = require_parseList(); + var ProgressTracker_1 = require_ProgressTracker(); + var StringWriter_1 = require_StringWriter(); + var parseListMLSD_1 = require_parseListMLSD(); + var netUtils_1 = require_netUtils(); + var transfer_1 = require_transfer(); + var parseControlResponse_1 = require_parseControlResponse(); + var fsReadDir = (0, util_1.promisify)(fs_1.readdir); + var fsMkDir = (0, util_1.promisify)(fs_1.mkdir); + var fsStat = (0, util_1.promisify)(fs_1.stat); + var fsOpen = (0, util_1.promisify)(fs_1.open); + var fsClose = (0, util_1.promisify)(fs_1.close); + var fsUnlink = (0, util_1.promisify)(fs_1.unlink); + var LIST_COMMANDS_DEFAULT = () => ["LIST -a", "LIST"]; + var LIST_COMMANDS_MLSD = () => ["MLSD", "LIST -a", "LIST"]; + var Client = class { + /** + * Instantiate an FTP client. + * + * @param timeout Timeout in milliseconds, use 0 for no timeout. Optional, default is 30 seconds. + */ + constructor(timeout2 = 3e4) { + this.availableListCommands = LIST_COMMANDS_DEFAULT(); + this.ftp = new FtpContext_1.FTPContext(timeout2); + this.prepareTransfer = this._enterFirstCompatibleMode([transfer_1.enterPassiveModeIPv6, transfer_1.enterPassiveModeIPv4]); + this.parseList = parseList_1.parseList; + this._progressTracker = new ProgressTracker_1.ProgressTracker(); + } + /** + * Close the client and all open socket connections. + * + * Close the client and all open socket connections. The client can’t be used anymore after calling this method, + * you have to either reconnect with `access` or `connect` or instantiate a new instance to continue any work. + * A client is also closed automatically if any timeout or connection error occurs. + */ + close() { + this.ftp.close(); + this._progressTracker.stop(); + } + /** + * Returns true if the client is closed and can't be used anymore. + */ + get closed() { + return this.ftp.closed; + } + /** + * Connect (or reconnect) to an FTP server. + * + * This is an instance method and thus can be called multiple times during the lifecycle of a `Client` + * instance. Whenever you do, the client is reset with a new control connection. This also implies that + * you can reopen a `Client` instance that has been closed due to an error when reconnecting with this + * method. In fact, reconnecting is the only way to continue using a closed `Client`. + * + * @param host Host the client should connect to. Optional, default is "localhost". + * @param port Port the client should connect to. Optional, default is 21. + */ + connect(host = "localhost", port = 21) { + this.ftp.reset(); + this.ftp.socket.connect({ + host, + port, + family: this.ftp.ipFamily + }, () => this.ftp.log(`Connected to ${(0, netUtils_1.describeAddress)(this.ftp.socket)} (${(0, netUtils_1.describeTLS)(this.ftp.socket)})`)); + return this._handleConnectResponse(); + } + /** + * As `connect` but using implicit TLS. Implicit TLS is not an FTP standard and has been replaced by + * explicit TLS. There are still FTP servers that support only implicit TLS, though. + */ + connectImplicitTLS(host = "localhost", port = 21, tlsOptions = {}) { + this.ftp.reset(); + this.ftp.socket = (0, tls_1.connect)(port, host, tlsOptions, () => this.ftp.log(`Connected to ${(0, netUtils_1.describeAddress)(this.ftp.socket)} (${(0, netUtils_1.describeTLS)(this.ftp.socket)})`)); + this.ftp.tlsOptions = tlsOptions; + return this._handleConnectResponse(); + } + /** + * Handles the first reponse by an FTP server after the socket connection has been established. + */ + _handleConnectResponse() { + return this.ftp.handle(void 0, (res, task) => { + if (res instanceof Error) { + task.reject(res); + } else if ((0, parseControlResponse_1.positiveCompletion)(res.code)) { + task.resolve(res); + } else { + task.reject(new FtpContext_1.FTPError(res)); + } + }); + } + /** + * Send an FTP command and handle the first response. + */ + send(command2, ignoreErrorCodesDEPRECATED = false) { + if (ignoreErrorCodesDEPRECATED) { + this.ftp.log("Deprecated call using send(command, flag) with boolean flag to ignore errors. Use sendIgnoringError(command)."); + return this.sendIgnoringError(command2); + } + return this.ftp.request(command2); + } + /** + * Send an FTP command and ignore an FTP error response. Any other kind of error or timeout will still reject the Promise. + * + * @param command + */ + sendIgnoringError(command2) { + return this.ftp.handle(command2, (res, task) => { + if (res instanceof FtpContext_1.FTPError) { + task.resolve({ code: res.code, message: res.message }); + } else if (res instanceof Error) { + task.reject(res); + } else { + task.resolve(res); + } + }); + } + /** + * Upgrade the current socket connection to TLS. + * + * @param options TLS options as in `tls.connect(options)`, optional. + * @param command Set the authentication command. Optional, default is "AUTH TLS". + */ + async useTLS(options = {}, command2 = "AUTH TLS") { + const ret = await this.send(command2); + this.ftp.socket = await (0, netUtils_1.upgradeSocket)(this.ftp.socket, options); + this.ftp.tlsOptions = options; + this.ftp.log(`Control socket is using: ${(0, netUtils_1.describeTLS)(this.ftp.socket)}`); + return ret; + } + /** + * Login a user with a password. + * + * @param user Username to use for login. Optional, default is "anonymous". + * @param password Password to use for login. Optional, default is "guest". + */ + login(user = "anonymous", password = "guest") { + this.ftp.log(`Login security: ${(0, netUtils_1.describeTLS)(this.ftp.socket)}`); + return this.ftp.handle("USER " + user, (res, task) => { + if (res instanceof Error) { + task.reject(res); + } else if ((0, parseControlResponse_1.positiveCompletion)(res.code)) { + task.resolve(res); + } else if (res.code === 331) { + this.ftp.send("PASS " + password); + } else { + task.reject(new FtpContext_1.FTPError(res)); + } + }); + } + /** + * Set the usual default settings. + * + * Settings used: + * * Binary mode (TYPE I) + * * File structure (STRU F) + * * Additional settings for FTPS (PBSZ 0, PROT P) + */ + async useDefaultSettings() { + const features = await this.features(); + const supportsMLSD = features.has("MLST"); + this.availableListCommands = supportsMLSD ? LIST_COMMANDS_MLSD() : LIST_COMMANDS_DEFAULT(); + await this.send("TYPE I"); + await this.sendIgnoringError("STRU F"); + await this.sendIgnoringError("OPTS UTF8 ON"); + if (supportsMLSD) { + await this.sendIgnoringError("OPTS MLST type;size;modify;unique;unix.mode;unix.owner;unix.group;unix.ownername;unix.groupname;"); + } + if (this.ftp.hasTLS) { + await this.sendIgnoringError("PBSZ 0"); + await this.sendIgnoringError("PROT P"); + } + } + /** + * Convenience method that calls `connect`, `useTLS`, `login` and `useDefaultSettings`. + * + * This is an instance method and thus can be called multiple times during the lifecycle of a `Client` + * instance. Whenever you do, the client is reset with a new control connection. This also implies that + * you can reopen a `Client` instance that has been closed due to an error when reconnecting with this + * method. In fact, reconnecting is the only way to continue using a closed `Client`. + */ + async access(options = {}) { + var _a2, _b2; + const useExplicitTLS = options.secure === true; + const useImplicitTLS = options.secure === "implicit"; + let welcome; + if (useImplicitTLS) { + welcome = await this.connectImplicitTLS(options.host, options.port, options.secureOptions); + } else { + welcome = await this.connect(options.host, options.port); + } + if (useExplicitTLS) { + const secureOptions = (_a2 = options.secureOptions) !== null && _a2 !== void 0 ? _a2 : {}; + secureOptions.host = (_b2 = secureOptions.host) !== null && _b2 !== void 0 ? _b2 : options.host; + await this.useTLS(secureOptions); + } + await this.sendIgnoringError("OPTS UTF8 ON"); + await this.login(options.user, options.password); + await this.useDefaultSettings(); + return welcome; + } + /** + * Get the current working directory. + */ + async pwd() { + const res = await this.send("PWD"); + const parsed = res.message.match(/"(.+)"/); + if (parsed === null || parsed[1] === void 0) { + throw new Error(`Can't parse response to command 'PWD': ${res.message}`); + } + return parsed[1]; + } + /** + * Get a description of supported features. + * + * This sends the FEAT command and parses the result into a Map where keys correspond to available commands + * and values hold further information. Be aware that your FTP servers might not support this + * command in which case this method will not throw an exception but just return an empty Map. + */ + async features() { + const res = await this.sendIgnoringError("FEAT"); + const features = /* @__PURE__ */ new Map(); + if (res.code < 400 && (0, parseControlResponse_1.isMultiline)(res.message)) { + res.message.split("\n").slice(1, -1).forEach((line) => { + const entry = line.trim().split(" "); + features.set(entry[0], entry[1] || ""); + }); + } + return features; + } + /** + * Set the working directory. + */ + async cd(path10) { + const validPath = await this.protectWhitespace(path10); + return this.send("CWD " + validPath); + } + /** + * Switch to the parent directory of the working directory. + */ + async cdup() { + return this.send("CDUP"); + } + /** + * Get the last modified time of a file. This is not supported by every FTP server, in which case + * calling this method will throw an exception. + */ + async lastMod(path10) { + const validPath = await this.protectWhitespace(path10); + const res = await this.send(`MDTM ${validPath}`); + const date = res.message.slice(4); + return (0, parseListMLSD_1.parseMLSxDate)(date); + } + /** + * Get the size of a file. + */ + async size(path10) { + const validPath = await this.protectWhitespace(path10); + const command2 = `SIZE ${validPath}`; + const res = await this.send(command2); + const size = parseInt(res.message.slice(4), 10); + if (Number.isNaN(size)) { + throw new Error(`Can't parse response to command '${command2}' as a numerical value: ${res.message}`); + } + return size; + } + /** + * Rename a file. + * + * Depending on the FTP server this might also be used to move a file from one + * directory to another by providing full paths. + */ + async rename(srcPath, destPath) { + const validSrc = await this.protectWhitespace(srcPath); + const validDest = await this.protectWhitespace(destPath); + await this.send("RNFR " + validSrc); + return this.send("RNTO " + validDest); + } + /** + * Remove a file from the current working directory. + * + * You can ignore FTP error return codes which won't throw an exception if e.g. + * the file doesn't exist. + */ + async remove(path10, ignoreErrorCodes = false) { + const validPath = await this.protectWhitespace(path10); + if (ignoreErrorCodes) { + return this.sendIgnoringError(`DELE ${validPath}`); + } + return this.send(`DELE ${validPath}`); + } + /** + * Report transfer progress for any upload or download to a given handler. + * + * This will also reset the overall transfer counter that can be used for multiple transfers. You can + * also call the function without a handler to stop reporting to an earlier one. + * + * @param handler Handler function to call on transfer progress. + */ + trackProgress(handler) { + this._progressTracker.bytesOverall = 0; + this._progressTracker.reportTo(handler); + } + /** + * Upload data from a readable stream or a local file to a remote file. + * + * @param source Readable stream or path to a local file. + * @param toRemotePath Path to a remote file to write to. + */ + async uploadFrom(source, toRemotePath, options = {}) { + return this._uploadWithCommand(source, toRemotePath, "STOR", options); + } + /** + * Upload data from a readable stream or a local file by appending it to an existing file. If the file doesn't + * exist the FTP server should create it. + * + * @param source Readable stream or path to a local file. + * @param toRemotePath Path to a remote file to write to. + */ + async appendFrom(source, toRemotePath, options = {}) { + return this._uploadWithCommand(source, toRemotePath, "APPE", options); + } + /** + * @protected + */ + async _uploadWithCommand(source, remotePath, command2, options) { + if (typeof source === "string") { + return this._uploadLocalFile(source, remotePath, command2, options); + } + return this._uploadFromStream(source, remotePath, command2); + } + /** + * @protected + */ + async _uploadLocalFile(localPath, remotePath, command2, options) { + const fd = await fsOpen(localPath, "r"); + const source = (0, fs_1.createReadStream)("", { + fd, + start: options.localStart, + end: options.localEndInclusive, + autoClose: false + }); + try { + return await this._uploadFromStream(source, remotePath, command2); + } finally { + await ignoreError(() => fsClose(fd)); + } + } + /** + * @protected + */ + async _uploadFromStream(source, remotePath, command2) { + const onError = (err) => this.ftp.closeWithError(err); + source.once("error", onError); + try { + const validPath = await this.protectWhitespace(remotePath); + await this.prepareTransfer(this.ftp); + return await (0, transfer_1.uploadFrom)(source, { + ftp: this.ftp, + tracker: this._progressTracker, + command: command2, + remotePath: validPath, + type: "upload" + }); + } finally { + source.removeListener("error", onError); + } + } + /** + * Download a remote file and pipe its data to a writable stream or to a local file. + * + * You can optionally define at which position of the remote file you'd like to start + * downloading. If the destination you provide is a file, the offset will be applied + * to it as well. For example: To resume a failed download, you'd request the size of + * the local, partially downloaded file and use that as the offset. Assuming the size + * is 23, you'd download the rest using `downloadTo("local.txt", "remote.txt", 23)`. + * + * @param destination Stream or path for a local file to write to. + * @param fromRemotePath Path of the remote file to read from. + * @param startAt Position within the remote file to start downloading at. If the destination is a file, this offset is also applied to it. + */ + async downloadTo(destination, fromRemotePath, startAt = 0) { + if (typeof destination === "string") { + return this._downloadToFile(destination, fromRemotePath, startAt); + } + return this._downloadToStream(destination, fromRemotePath, startAt); + } + /** + * @protected + */ + async _downloadToFile(localPath, remotePath, startAt) { + const appendingToLocalFile = startAt > 0; + const fileSystemFlags = appendingToLocalFile ? "r+" : "w"; + const fd = await fsOpen(localPath, fileSystemFlags); + const destination = (0, fs_1.createWriteStream)("", { + fd, + start: startAt, + autoClose: false + }); + try { + return await this._downloadToStream(destination, remotePath, startAt); + } catch (err) { + const localFileStats = await ignoreError(() => fsStat(localPath)); + const hasDownloadedData = localFileStats && localFileStats.size > 0; + const shouldRemoveLocalFile = !appendingToLocalFile && !hasDownloadedData; + if (shouldRemoveLocalFile) { + await ignoreError(() => fsUnlink(localPath)); + } + throw err; + } finally { + await ignoreError(() => fsClose(fd)); + } + } + /** + * @protected + */ + async _downloadToStream(destination, remotePath, startAt) { + const onError = (err) => this.ftp.closeWithError(err); + destination.once("error", onError); + try { + const validPath = await this.protectWhitespace(remotePath); + await this.prepareTransfer(this.ftp); + return await (0, transfer_1.downloadTo)(destination, { + ftp: this.ftp, + tracker: this._progressTracker, + command: startAt > 0 ? `REST ${startAt}` : `RETR ${validPath}`, + remotePath: validPath, + type: "download" + }); + } finally { + destination.removeListener("error", onError); + destination.end(); + } + } + /** + * List files and directories in the current working directory, or from `path` if specified. + * + * @param [path] Path to remote file or directory. + */ + async list(path10 = "") { + const validPath = await this.protectWhitespace(path10); + let lastError; + for (const candidate of this.availableListCommands) { + const command2 = validPath === "" ? candidate : `${candidate} ${validPath}`; + await this.prepareTransfer(this.ftp); + try { + const parsedList = await this._requestListWithCommand(command2); + this.availableListCommands = [candidate]; + return parsedList; + } catch (err) { + const shouldTryNext = err instanceof FtpContext_1.FTPError; + if (!shouldTryNext) { + throw err; + } + lastError = err; + } + } + throw lastError; + } + /** + * @protected + */ + async _requestListWithCommand(command2) { + const buffer = new StringWriter_1.StringWriter(); + await (0, transfer_1.downloadTo)(buffer, { + ftp: this.ftp, + tracker: this._progressTracker, + command: command2, + remotePath: "", + type: "list" + }); + const text = buffer.getText(this.ftp.encoding); + this.ftp.log(text); + return this.parseList(text); + } + /** + * Remove a directory and all of its content. + * + * @param remoteDirPath The path of the remote directory to delete. + * @example client.removeDir("foo") // Remove directory 'foo' using a relative path. + * @example client.removeDir("foo/bar") // Remove directory 'bar' using a relative path. + * @example client.removeDir("/foo/bar") // Remove directory 'bar' using an absolute path. + * @example client.removeDir("/") // Remove everything. + */ + async removeDir(remoteDirPath) { + return this._exitAtCurrentDirectory(async () => { + await this.cd(remoteDirPath); + const absoluteDirPath = await this.pwd(); + await this.clearWorkingDir(); + const dirIsRoot = absoluteDirPath === "/"; + if (!dirIsRoot) { + await this.cdup(); + await this.removeEmptyDir(absoluteDirPath); + } + }); + } + /** + * Remove all files and directories in the working directory without removing + * the working directory itself. + */ + async clearWorkingDir() { + for (const file of await this.list()) { + if (file.isDirectory) { + await this.cd(file.name); + await this.clearWorkingDir(); + await this.cdup(); + await this.removeEmptyDir(file.name); + } else { + await this.remove(file.name); + } + } + } + /** + * Upload the contents of a local directory to the remote working directory. + * + * This will overwrite existing files with the same names and reuse existing directories. + * Unrelated files and directories will remain untouched. You can optionally provide a `remoteDirPath` + * to put the contents inside a directory which will be created if necessary including all + * intermediate directories. If you did provide a remoteDirPath the working directory will stay + * the same as before calling this method. + * + * @param localDirPath Local path, e.g. "foo/bar" or "../test" + * @param [remoteDirPath] Remote path of a directory to upload to. Working directory if undefined. + */ + async uploadFromDir(localDirPath, remoteDirPath) { + return this._exitAtCurrentDirectory(async () => { + if (remoteDirPath) { + await this.ensureDir(remoteDirPath); + } + return await this._uploadToWorkingDir(localDirPath); + }); + } + /** + * @protected + */ + async _uploadToWorkingDir(localDirPath) { + const files = await fsReadDir(localDirPath); + for (const file of files) { + const fullPath = (0, path_1.join)(localDirPath, file); + const stats = await fsStat(fullPath); + if (stats.isFile()) { + await this.uploadFrom(fullPath, file); + } else if (stats.isDirectory()) { + await this._openDir(file); + await this._uploadToWorkingDir(fullPath); + await this.cdup(); + } + } + } + /** + * Download all files and directories of the working directory to a local directory. + * + * @param localDirPath The local directory to download to. + * @param remoteDirPath Remote directory to download. Current working directory if not specified. + */ + async downloadToDir(localDirPath, remoteDirPath) { + return this._exitAtCurrentDirectory(async () => { + if (remoteDirPath) { + await this.cd(remoteDirPath); + } + return await this._downloadFromWorkingDir(localDirPath); + }); + } + /** + * @protected + */ + async _downloadFromWorkingDir(localDirPath) { + await ensureLocalDirectory(localDirPath); + for (const file of await this.list()) { + const localPath = (0, path_1.join)(localDirPath, file.name); + if (file.isDirectory) { + await this.cd(file.name); + await this._downloadFromWorkingDir(localPath); + await this.cdup(); + } else if (file.isFile) { + await this.downloadTo(localPath, file.name); + } + } + } + /** + * Make sure a given remote path exists, creating all directories as necessary. + * This function also changes the current working directory to the given path. + */ + async ensureDir(remoteDirPath) { + if (remoteDirPath.startsWith("/")) { + await this.cd("/"); + } + const names = remoteDirPath.split("/").filter((name) => name !== ""); + for (const name of names) { + await this._openDir(name); + } + } + /** + * Try to create a directory and enter it. This will not raise an exception if the directory + * couldn't be created if for example it already exists. + * @protected + */ + async _openDir(dirName) { + await this.sendIgnoringError("MKD " + dirName); + await this.cd(dirName); + } + /** + * Remove an empty directory, will fail if not empty. + */ + async removeEmptyDir(path10) { + const validPath = await this.protectWhitespace(path10); + return this.send(`RMD ${validPath}`); + } + /** + * FTP servers can't handle filenames that have leading whitespace. This method transforms + * a given path to fix that issue for most cases. + */ + async protectWhitespace(path10) { + if (!path10.startsWith(" ")) { + return path10; + } + const pwd = await this.pwd(); + const absolutePathPrefix = pwd.endsWith("/") ? pwd : pwd + "/"; + return absolutePathPrefix + path10; + } + async _exitAtCurrentDirectory(func) { + const userDir = await this.pwd(); + try { + return await func(); + } finally { + if (!this.closed) { + await ignoreError(() => this.cd(userDir)); + } + } + } + /** + * Try all available transfer strategies and pick the first one that works. Update `client` to + * use the working strategy for all successive transfer requests. + * + * @returns a function that will try the provided strategies. + */ + _enterFirstCompatibleMode(strategies) { + return async (ftp) => { + ftp.log("Trying to find optimal transfer strategy..."); + let lastError = void 0; + for (const strategy of strategies) { + try { + const res = await strategy(ftp); + ftp.log("Optimal transfer strategy found."); + this.prepareTransfer = strategy; + return res; + } catch (err) { + lastError = err; + } + } + throw new Error(`None of the available transfer strategies work. Last error response was '${lastError}'.`); + }; + } + /** + * DEPRECATED, use `uploadFrom`. + * @deprecated + */ + async upload(source, toRemotePath, options = {}) { + this.ftp.log("Warning: upload() has been deprecated, use uploadFrom()."); + return this.uploadFrom(source, toRemotePath, options); + } + /** + * DEPRECATED, use `appendFrom`. + * @deprecated + */ + async append(source, toRemotePath, options = {}) { + this.ftp.log("Warning: append() has been deprecated, use appendFrom()."); + return this.appendFrom(source, toRemotePath, options); + } + /** + * DEPRECATED, use `downloadTo`. + * @deprecated + */ + async download(destination, fromRemotePath, startAt = 0) { + this.ftp.log("Warning: download() has been deprecated, use downloadTo()."); + return this.downloadTo(destination, fromRemotePath, startAt); + } + /** + * DEPRECATED, use `uploadFromDir`. + * @deprecated + */ + async uploadDir(localDirPath, remoteDirPath) { + this.ftp.log("Warning: uploadDir() has been deprecated, use uploadFromDir()."); + return this.uploadFromDir(localDirPath, remoteDirPath); + } + /** + * DEPRECATED, use `downloadToDir`. + * @deprecated + */ + async downloadDir(localDirPath) { + this.ftp.log("Warning: downloadDir() has been deprecated, use downloadToDir()."); + return this.downloadToDir(localDirPath); + } + }; + exports.Client = Client; + async function ensureLocalDirectory(path10) { + try { + await fsStat(path10); + } catch (err) { + await fsMkDir(path10, { recursive: true }); + } + } + async function ignoreError(func) { + try { + return await func(); + } catch (err) { + return void 0; + } + } + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/StringEncoding.js +var require_StringEncoding = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/StringEncoding.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + } +}); + +// ../testeranto/node_modules/basic-ftp/dist/index.js +var require_dist5 = __commonJS({ + "../testeranto/node_modules/basic-ftp/dist/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __exportStar2 = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) + __createBinding2(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.enterPassiveModeIPv6 = exports.enterPassiveModeIPv4 = void 0; + __exportStar2(require_Client(), exports); + __exportStar2(require_FtpContext(), exports); + __exportStar2(require_FileInfo(), exports); + __exportStar2(require_parseList(), exports); + __exportStar2(require_StringEncoding(), exports); + var transfer_1 = require_transfer(); + Object.defineProperty(exports, "enterPassiveModeIPv4", { enumerable: true, get: function() { + return transfer_1.enterPassiveModeIPv4; + } }); + Object.defineProperty(exports, "enterPassiveModeIPv6", { enumerable: true, get: function() { + return transfer_1.enterPassiveModeIPv6; + } }); + } +}); + +// ../testeranto/node_modules/get-uri/dist/ftp.js +var require_ftp = __commonJS({ + "../testeranto/node_modules/get-uri/dist/ftp.js"(exports) { + "use strict"; + init_cjs_shim(); + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ftp = void 0; + var basic_ftp_1 = require_dist5(); + var stream_1 = __require("stream"); + var path_1 = __require("path"); + var debug_1 = __importDefault2(require_src()); + var notfound_1 = __importDefault2(require_notfound()); + var notmodified_1 = __importDefault2(require_notmodified()); + var debug5 = (0, debug_1.default)("get-uri:ftp"); + var ftp = async (url, opts = {}) => { + const { cache } = opts; + const filepath = decodeURIComponent(url.pathname); + let lastModified; + if (!filepath) { + throw new TypeError('No "pathname"!'); + } + const client = new basic_ftp_1.Client(); + try { + const host = url.hostname || url.host || "localhost"; + const port = parseInt(url.port || "0", 10) || 21; + const user = url.username ? decodeURIComponent(url.username) : void 0; + const password = url.password ? decodeURIComponent(url.password) : void 0; + await client.access({ + host, + port, + user, + password, + ...opts + }); + try { + lastModified = await client.lastMod(filepath); + } catch (err) { + if (err.code === 550) { + throw new notfound_1.default(); + } + } + if (!lastModified) { + const list = await client.list((0, path_1.dirname)(filepath)); + const name = (0, path_1.basename)(filepath); + const entry = list.find((e) => e.name === name); + if (entry) { + lastModified = entry.modifiedAt; + } + } + if (lastModified) { + if (isNotModified()) { + throw new notmodified_1.default(); + } + } else { + throw new notfound_1.default(); + } + const stream = new stream_1.PassThrough(); + const rs = stream; + client.downloadTo(stream, filepath).then((result) => { + debug5(result.message); + client.close(); + }); + rs.lastModified = lastModified; + return rs; + } catch (err) { + client.close(); + throw err; + } + function isNotModified() { + if (cache?.lastModified && lastModified) { + return +cache.lastModified === +lastModified; + } + return false; + } + }; + exports.ftp = ftp; + } +}); + +// ../testeranto/node_modules/get-uri/dist/http-error.js +var require_http_error = __commonJS({ + "../testeranto/node_modules/get-uri/dist/http-error.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var http_1 = __require("http"); + var HTTPError = class extends Error { + constructor(statusCode, message = http_1.STATUS_CODES[statusCode]) { + super(message); + this.statusCode = statusCode; + this.code = `E${String(message).toUpperCase().replace(/\s+/g, "")}`; + } + }; + exports.default = HTTPError; + } +}); + +// ../testeranto/node_modules/get-uri/dist/http.js +var require_http = __commonJS({ + "../testeranto/node_modules/get-uri/dist/http.js"(exports) { + "use strict"; + init_cjs_shim(); + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.http = void 0; + var http_1 = __importDefault2(__require("http")); + var https_1 = __importDefault2(__require("https")); + var events_1 = __require("events"); + var debug_1 = __importDefault2(require_src()); + var http_error_1 = __importDefault2(require_http_error()); + var notfound_1 = __importDefault2(require_notfound()); + var notmodified_1 = __importDefault2(require_notmodified()); + var debug5 = (0, debug_1.default)("get-uri:http"); + var http2 = async (url, opts = {}) => { + debug5("GET %o", url.href); + const cache = getCache(url, opts.cache); + if (cache && isFresh(cache) && typeof cache.statusCode === "number") { + const type2 = cache.statusCode / 100 | 0; + if (type2 === 3 && cache.headers.location) { + debug5("cached redirect"); + throw new Error("TODO: implement cached redirects!"); + } + throw new notmodified_1.default(); + } + const maxRedirects = typeof opts.maxRedirects === "number" ? opts.maxRedirects : 5; + debug5("allowing %o max redirects", maxRedirects); + let mod; + if (opts.http) { + mod = opts.http; + debug5("using secure `https` core module"); + } else { + mod = http_1.default; + debug5("using `http` core module"); + } + const options = { ...opts }; + if (cache) { + if (!options.headers) { + options.headers = {}; + } + const lastModified = cache.headers["last-modified"]; + if (lastModified) { + options.headers["If-Modified-Since"] = lastModified; + debug5('added "If-Modified-Since" request header: %o', lastModified); + } + const etag = cache.headers.etag; + if (etag) { + options.headers["If-None-Match"] = etag; + debug5('added "If-None-Match" request header: %o', etag); + } + } + const req = mod.get(url, options); + const [res] = await (0, events_1.once)(req, "response"); + const code = res.statusCode || 0; + res.date = Date.now(); + res.parsed = url; + debug5("got %o response status code", code); + const type = code / 100 | 0; + const location = res.headers.location; + if (type === 3 && location) { + if (!opts.redirects) + opts.redirects = []; + const redirects = opts.redirects; + if (redirects.length < maxRedirects) { + debug5('got a "redirect" status code with Location: %o', location); + res.resume(); + redirects.push(res); + const newUri = new URL(location, url.href); + debug5("resolved redirect URL: %o", newUri.href); + const left2 = maxRedirects - redirects.length; + debug5("%o more redirects allowed after this one", left2); + if (newUri.protocol !== url.protocol) { + opts.http = newUri.protocol === "https:" ? https_1.default : void 0; + } + return (0, exports.http)(newUri, opts); + } + } + if (type !== 2) { + res.resume(); + if (code === 304) { + throw new notmodified_1.default(); + } else if (code === 404) { + throw new notfound_1.default(); + } + throw new http_error_1.default(code); + } + if (opts.redirects) { + res.redirects = opts.redirects; + } + return res; + }; + exports.http = http2; + function isFresh(cache) { + let fresh = false; + let expires = parseInt(cache.headers.expires || "", 10); + const cacheControl = cache.headers["cache-control"]; + if (cacheControl) { + debug5("Cache-Control: %o", cacheControl); + const parts = cacheControl.split(/,\s*?\b/); + for (let i = 0; i < parts.length; i++) { + const part = parts[i]; + const subparts = part.split("="); + const name = subparts[0]; + switch (name) { + case "max-age": + expires = (cache.date || 0) + parseInt(subparts[1], 10) * 1e3; + fresh = Date.now() < expires; + if (fresh) { + debug5('cache is "fresh" due to previous %o Cache-Control param', part); + } + return fresh; + case "must-revalidate": + break; + case "no-cache": + case "no-store": + debug5('cache is "stale" due to explicit %o Cache-Control param', name); + return false; + default: + break; + } + } + } else if (expires) { + debug5("Expires: %o", expires); + fresh = Date.now() < expires; + if (fresh) { + debug5('cache is "fresh" due to previous Expires response header'); + } + return fresh; + } + return false; + } + function getCache(url, cache) { + if (cache) { + if (cache.parsed && cache.parsed.href === url.href) { + return cache; + } + if (cache.redirects) { + for (let i = 0; i < cache.redirects.length; i++) { + const c = getCache(url, cache.redirects[i]); + if (c) { + return c; + } + } + } + } + return null; + } + } +}); + +// ../testeranto/node_modules/get-uri/dist/https.js +var require_https = __commonJS({ + "../testeranto/node_modules/get-uri/dist/https.js"(exports) { + "use strict"; + init_cjs_shim(); + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.https = void 0; + var https_1 = __importDefault2(__require("https")); + var http_1 = require_http(); + var https2 = (url, opts) => { + return (0, http_1.http)(url, { ...opts, http: https_1.default }); + }; + exports.https = https2; + } +}); + +// ../testeranto/node_modules/get-uri/dist/index.js +var require_dist6 = __commonJS({ + "../testeranto/node_modules/get-uri/dist/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getUri = exports.isValidProtocol = exports.protocols = void 0; + var debug_1 = __importDefault2(require_src()); + var data_1 = require_data(); + var file_1 = require_file2(); + var ftp_1 = require_ftp(); + var http_1 = require_http(); + var https_1 = require_https(); + var debug5 = (0, debug_1.default)("get-uri"); + exports.protocols = { + data: data_1.data, + file: file_1.file, + ftp: ftp_1.ftp, + http: http_1.http, + https: https_1.https + }; + var VALID_PROTOCOLS = new Set(Object.keys(exports.protocols)); + function isValidProtocol(p) { + return VALID_PROTOCOLS.has(p); + } + exports.isValidProtocol = isValidProtocol; + async function getUri(uri, opts) { + debug5("getUri(%o)", uri); + if (!uri) { + throw new TypeError('Must pass in a URI to "getUri()"'); + } + const url = typeof uri === "string" ? new URL(uri) : uri; + const protocol = url.protocol.replace(/:$/, ""); + if (!isValidProtocol(protocol)) { + throw new TypeError(`Unsupported protocol "${protocol}" specified in URI: "${uri}"`); + } + const getter = exports.protocols[protocol]; + return getter(url, opts); + } + exports.getUri = getUri; + } +}); + +// ../testeranto/node_modules/estraverse/estraverse.js +var require_estraverse = __commonJS({ + "../testeranto/node_modules/estraverse/estraverse.js"(exports) { + init_cjs_shim(); + (function clone(exports2) { + "use strict"; + var Syntax, VisitorOption, VisitorKeys, BREAK, SKIP, REMOVE; + function deepCopy(obj) { + var ret = {}, key, val; + for (key in obj) { + if (obj.hasOwnProperty(key)) { + val = obj[key]; + if (typeof val === "object" && val !== null) { + ret[key] = deepCopy(val); + } else { + ret[key] = val; + } + } + } + return ret; + } + function upperBound(array, func) { + var diff, len, i, current; + len = array.length; + i = 0; + while (len) { + diff = len >>> 1; + current = i + diff; + if (func(array[current])) { + len = diff; + } else { + i = current + 1; + len -= diff + 1; + } + } + return i; + } + Syntax = { + AssignmentExpression: "AssignmentExpression", + AssignmentPattern: "AssignmentPattern", + ArrayExpression: "ArrayExpression", + ArrayPattern: "ArrayPattern", + ArrowFunctionExpression: "ArrowFunctionExpression", + AwaitExpression: "AwaitExpression", + // CAUTION: It's deferred to ES7. + BlockStatement: "BlockStatement", + BinaryExpression: "BinaryExpression", + BreakStatement: "BreakStatement", + CallExpression: "CallExpression", + CatchClause: "CatchClause", + ChainExpression: "ChainExpression", + ClassBody: "ClassBody", + ClassDeclaration: "ClassDeclaration", + ClassExpression: "ClassExpression", + ComprehensionBlock: "ComprehensionBlock", + // CAUTION: It's deferred to ES7. + ComprehensionExpression: "ComprehensionExpression", + // CAUTION: It's deferred to ES7. + ConditionalExpression: "ConditionalExpression", + ContinueStatement: "ContinueStatement", + DebuggerStatement: "DebuggerStatement", + DirectiveStatement: "DirectiveStatement", + DoWhileStatement: "DoWhileStatement", + EmptyStatement: "EmptyStatement", + ExportAllDeclaration: "ExportAllDeclaration", + ExportDefaultDeclaration: "ExportDefaultDeclaration", + ExportNamedDeclaration: "ExportNamedDeclaration", + ExportSpecifier: "ExportSpecifier", + ExpressionStatement: "ExpressionStatement", + ForStatement: "ForStatement", + ForInStatement: "ForInStatement", + ForOfStatement: "ForOfStatement", + FunctionDeclaration: "FunctionDeclaration", + FunctionExpression: "FunctionExpression", + GeneratorExpression: "GeneratorExpression", + // CAUTION: It's deferred to ES7. + Identifier: "Identifier", + IfStatement: "IfStatement", + ImportExpression: "ImportExpression", + ImportDeclaration: "ImportDeclaration", + ImportDefaultSpecifier: "ImportDefaultSpecifier", + ImportNamespaceSpecifier: "ImportNamespaceSpecifier", + ImportSpecifier: "ImportSpecifier", + Literal: "Literal", + LabeledStatement: "LabeledStatement", + LogicalExpression: "LogicalExpression", + MemberExpression: "MemberExpression", + MetaProperty: "MetaProperty", + MethodDefinition: "MethodDefinition", + ModuleSpecifier: "ModuleSpecifier", + NewExpression: "NewExpression", + ObjectExpression: "ObjectExpression", + ObjectPattern: "ObjectPattern", + PrivateIdentifier: "PrivateIdentifier", + Program: "Program", + Property: "Property", + PropertyDefinition: "PropertyDefinition", + RestElement: "RestElement", + ReturnStatement: "ReturnStatement", + SequenceExpression: "SequenceExpression", + SpreadElement: "SpreadElement", + Super: "Super", + SwitchStatement: "SwitchStatement", + SwitchCase: "SwitchCase", + TaggedTemplateExpression: "TaggedTemplateExpression", + TemplateElement: "TemplateElement", + TemplateLiteral: "TemplateLiteral", + ThisExpression: "ThisExpression", + ThrowStatement: "ThrowStatement", + TryStatement: "TryStatement", + UnaryExpression: "UnaryExpression", + UpdateExpression: "UpdateExpression", + VariableDeclaration: "VariableDeclaration", + VariableDeclarator: "VariableDeclarator", + WhileStatement: "WhileStatement", + WithStatement: "WithStatement", + YieldExpression: "YieldExpression" + }; + VisitorKeys = { + AssignmentExpression: ["left", "right"], + AssignmentPattern: ["left", "right"], + ArrayExpression: ["elements"], + ArrayPattern: ["elements"], + ArrowFunctionExpression: ["params", "body"], + AwaitExpression: ["argument"], + // CAUTION: It's deferred to ES7. + BlockStatement: ["body"], + BinaryExpression: ["left", "right"], + BreakStatement: ["label"], + CallExpression: ["callee", "arguments"], + CatchClause: ["param", "body"], + ChainExpression: ["expression"], + ClassBody: ["body"], + ClassDeclaration: ["id", "superClass", "body"], + ClassExpression: ["id", "superClass", "body"], + ComprehensionBlock: ["left", "right"], + // CAUTION: It's deferred to ES7. + ComprehensionExpression: ["blocks", "filter", "body"], + // CAUTION: It's deferred to ES7. + ConditionalExpression: ["test", "consequent", "alternate"], + ContinueStatement: ["label"], + DebuggerStatement: [], + DirectiveStatement: [], + DoWhileStatement: ["body", "test"], + EmptyStatement: [], + ExportAllDeclaration: ["source"], + ExportDefaultDeclaration: ["declaration"], + ExportNamedDeclaration: ["declaration", "specifiers", "source"], + ExportSpecifier: ["exported", "local"], + ExpressionStatement: ["expression"], + ForStatement: ["init", "test", "update", "body"], + ForInStatement: ["left", "right", "body"], + ForOfStatement: ["left", "right", "body"], + FunctionDeclaration: ["id", "params", "body"], + FunctionExpression: ["id", "params", "body"], + GeneratorExpression: ["blocks", "filter", "body"], + // CAUTION: It's deferred to ES7. + Identifier: [], + IfStatement: ["test", "consequent", "alternate"], + ImportExpression: ["source"], + ImportDeclaration: ["specifiers", "source"], + ImportDefaultSpecifier: ["local"], + ImportNamespaceSpecifier: ["local"], + ImportSpecifier: ["imported", "local"], + Literal: [], + LabeledStatement: ["label", "body"], + LogicalExpression: ["left", "right"], + MemberExpression: ["object", "property"], + MetaProperty: ["meta", "property"], + MethodDefinition: ["key", "value"], + ModuleSpecifier: [], + NewExpression: ["callee", "arguments"], + ObjectExpression: ["properties"], + ObjectPattern: ["properties"], + PrivateIdentifier: [], + Program: ["body"], + Property: ["key", "value"], + PropertyDefinition: ["key", "value"], + RestElement: ["argument"], + ReturnStatement: ["argument"], + SequenceExpression: ["expressions"], + SpreadElement: ["argument"], + Super: [], + SwitchStatement: ["discriminant", "cases"], + SwitchCase: ["test", "consequent"], + TaggedTemplateExpression: ["tag", "quasi"], + TemplateElement: [], + TemplateLiteral: ["quasis", "expressions"], + ThisExpression: [], + ThrowStatement: ["argument"], + TryStatement: ["block", "handler", "finalizer"], + UnaryExpression: ["argument"], + UpdateExpression: ["argument"], + VariableDeclaration: ["declarations"], + VariableDeclarator: ["id", "init"], + WhileStatement: ["test", "body"], + WithStatement: ["object", "body"], + YieldExpression: ["argument"] + }; + BREAK = {}; + SKIP = {}; + REMOVE = {}; + VisitorOption = { + Break: BREAK, + Skip: SKIP, + Remove: REMOVE + }; + function Reference(parent, key) { + this.parent = parent; + this.key = key; + } + Reference.prototype.replace = function replace2(node) { + this.parent[this.key] = node; + }; + Reference.prototype.remove = function remove() { + if (Array.isArray(this.parent)) { + this.parent.splice(this.key, 1); + return true; + } else { + this.replace(null); + return false; + } + }; + function Element(node, path10, wrap2, ref) { + this.node = node; + this.path = path10; + this.wrap = wrap2; + this.ref = ref; + } + function Controller() { + } + Controller.prototype.path = function path10() { + var i, iz, j, jz, result, element; + function addToPath(result2, path11) { + if (Array.isArray(path11)) { + for (j = 0, jz = path11.length; j < jz; ++j) { + result2.push(path11[j]); + } + } else { + result2.push(path11); + } + } + if (!this.__current.path) { + return null; + } + result = []; + for (i = 2, iz = this.__leavelist.length; i < iz; ++i) { + element = this.__leavelist[i]; + addToPath(result, element.path); + } + addToPath(result, this.__current.path); + return result; + }; + Controller.prototype.type = function() { + var node = this.current(); + return node.type || this.__current.wrap; + }; + Controller.prototype.parents = function parents() { + var i, iz, result; + result = []; + for (i = 1, iz = this.__leavelist.length; i < iz; ++i) { + result.push(this.__leavelist[i].node); + } + return result; + }; + Controller.prototype.current = function current() { + return this.__current.node; + }; + Controller.prototype.__execute = function __execute(callback, element) { + var previous, result; + result = void 0; + previous = this.__current; + this.__current = element; + this.__state = null; + if (callback) { + result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node); + } + this.__current = previous; + return result; + }; + Controller.prototype.notify = function notify(flag) { + this.__state = flag; + }; + Controller.prototype.skip = function() { + this.notify(SKIP); + }; + Controller.prototype["break"] = function() { + this.notify(BREAK); + }; + Controller.prototype.remove = function() { + this.notify(REMOVE); + }; + Controller.prototype.__initialize = function(root, visitor) { + this.visitor = visitor; + this.root = root; + this.__worklist = []; + this.__leavelist = []; + this.__current = null; + this.__state = null; + this.__fallback = null; + if (visitor.fallback === "iteration") { + this.__fallback = Object.keys; + } else if (typeof visitor.fallback === "function") { + this.__fallback = visitor.fallback; + } + this.__keys = VisitorKeys; + if (visitor.keys) { + this.__keys = Object.assign(Object.create(this.__keys), visitor.keys); + } + }; + function isNode2(node) { + if (node == null) { + return false; + } + return typeof node === "object" && typeof node.type === "string"; + } + function isProperty(nodeType, key) { + return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && "properties" === key; + } + function candidateExistsInLeaveList(leavelist, candidate) { + for (var i = leavelist.length - 1; i >= 0; --i) { + if (leavelist[i].node === candidate) { + return true; + } + } + return false; + } + Controller.prototype.traverse = function traverse2(root, visitor) { + var worklist, leavelist, element, node, nodeType, ret, key, current, current2, candidates, candidate, sentinel; + this.__initialize(root, visitor); + sentinel = {}; + worklist = this.__worklist; + leavelist = this.__leavelist; + worklist.push(new Element(root, null, null, null)); + leavelist.push(new Element(null, null, null, null)); + while (worklist.length) { + element = worklist.pop(); + if (element === sentinel) { + element = leavelist.pop(); + ret = this.__execute(visitor.leave, element); + if (this.__state === BREAK || ret === BREAK) { + return; + } + continue; + } + if (element.node) { + ret = this.__execute(visitor.enter, element); + if (this.__state === BREAK || ret === BREAK) { + return; + } + worklist.push(sentinel); + leavelist.push(element); + if (this.__state === SKIP || ret === SKIP) { + continue; + } + node = element.node; + nodeType = node.type || element.wrap; + candidates = this.__keys[nodeType]; + if (!candidates) { + if (this.__fallback) { + candidates = this.__fallback(node); + } else { + throw new Error("Unknown node type " + nodeType + "."); + } + } + current = candidates.length; + while ((current -= 1) >= 0) { + key = candidates[current]; + candidate = node[key]; + if (!candidate) { + continue; + } + if (Array.isArray(candidate)) { + current2 = candidate.length; + while ((current2 -= 1) >= 0) { + if (!candidate[current2]) { + continue; + } + if (candidateExistsInLeaveList(leavelist, candidate[current2])) { + continue; + } + if (isProperty(nodeType, candidates[current])) { + element = new Element(candidate[current2], [key, current2], "Property", null); + } else if (isNode2(candidate[current2])) { + element = new Element(candidate[current2], [key, current2], null, null); + } else { + continue; + } + worklist.push(element); + } + } else if (isNode2(candidate)) { + if (candidateExistsInLeaveList(leavelist, candidate)) { + continue; + } + worklist.push(new Element(candidate, key, null, null)); + } + } + } + } + }; + Controller.prototype.replace = function replace2(root, visitor) { + var worklist, leavelist, node, nodeType, target, element, current, current2, candidates, candidate, sentinel, outer, key; + function removeElem(element2) { + var i, key2, nextElem, parent; + if (element2.ref.remove()) { + key2 = element2.ref.key; + parent = element2.ref.parent; + i = worklist.length; + while (i--) { + nextElem = worklist[i]; + if (nextElem.ref && nextElem.ref.parent === parent) { + if (nextElem.ref.key < key2) { + break; + } + --nextElem.ref.key; + } + } + } + } + this.__initialize(root, visitor); + sentinel = {}; + worklist = this.__worklist; + leavelist = this.__leavelist; + outer = { + root + }; + element = new Element(root, null, null, new Reference(outer, "root")); + worklist.push(element); + leavelist.push(element); + while (worklist.length) { + element = worklist.pop(); + if (element === sentinel) { + element = leavelist.pop(); + target = this.__execute(visitor.leave, element); + if (target !== void 0 && target !== BREAK && target !== SKIP && target !== REMOVE) { + element.ref.replace(target); + } + if (this.__state === REMOVE || target === REMOVE) { + removeElem(element); + } + if (this.__state === BREAK || target === BREAK) { + return outer.root; + } + continue; + } + target = this.__execute(visitor.enter, element); + if (target !== void 0 && target !== BREAK && target !== SKIP && target !== REMOVE) { + element.ref.replace(target); + element.node = target; + } + if (this.__state === REMOVE || target === REMOVE) { + removeElem(element); + element.node = null; + } + if (this.__state === BREAK || target === BREAK) { + return outer.root; + } + node = element.node; + if (!node) { + continue; + } + worklist.push(sentinel); + leavelist.push(element); + if (this.__state === SKIP || target === SKIP) { + continue; + } + nodeType = node.type || element.wrap; + candidates = this.__keys[nodeType]; + if (!candidates) { + if (this.__fallback) { + candidates = this.__fallback(node); + } else { + throw new Error("Unknown node type " + nodeType + "."); + } + } + current = candidates.length; + while ((current -= 1) >= 0) { + key = candidates[current]; + candidate = node[key]; + if (!candidate) { + continue; + } + if (Array.isArray(candidate)) { + current2 = candidate.length; + while ((current2 -= 1) >= 0) { + if (!candidate[current2]) { + continue; + } + if (isProperty(nodeType, candidates[current])) { + element = new Element(candidate[current2], [key, current2], "Property", new Reference(candidate, current2)); + } else if (isNode2(candidate[current2])) { + element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2)); + } else { + continue; + } + worklist.push(element); + } + } else if (isNode2(candidate)) { + worklist.push(new Element(candidate, key, null, new Reference(node, key))); + } + } + } + return outer.root; + }; + function traverse(root, visitor) { + var controller = new Controller(); + return controller.traverse(root, visitor); + } + function replace(root, visitor) { + var controller = new Controller(); + return controller.replace(root, visitor); + } + function extendCommentRange(comment, tokens) { + var target; + target = upperBound(tokens, function search(token) { + return token.range[0] > comment.range[0]; + }); + comment.extendedRange = [comment.range[0], comment.range[1]]; + if (target !== tokens.length) { + comment.extendedRange[1] = tokens[target].range[0]; + } + target -= 1; + if (target >= 0) { + comment.extendedRange[0] = tokens[target].range[1]; + } + return comment; + } + function attachComments(tree, providedComments, tokens) { + var comments = [], comment, len, i, cursor; + if (!tree.range) { + throw new Error("attachComments needs range information"); + } + if (!tokens.length) { + if (providedComments.length) { + for (i = 0, len = providedComments.length; i < len; i += 1) { + comment = deepCopy(providedComments[i]); + comment.extendedRange = [0, tree.range[0]]; + comments.push(comment); + } + tree.leadingComments = comments; + } + return tree; + } + for (i = 0, len = providedComments.length; i < len; i += 1) { + comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens)); + } + cursor = 0; + traverse(tree, { + enter: function(node) { + var comment2; + while (cursor < comments.length) { + comment2 = comments[cursor]; + if (comment2.extendedRange[1] > node.range[0]) { + break; + } + if (comment2.extendedRange[1] === node.range[0]) { + if (!node.leadingComments) { + node.leadingComments = []; + } + node.leadingComments.push(comment2); + comments.splice(cursor, 1); + } else { + cursor += 1; + } + } + if (cursor === comments.length) { + return VisitorOption.Break; + } + if (comments[cursor].extendedRange[0] > node.range[1]) { + return VisitorOption.Skip; + } + } + }); + cursor = 0; + traverse(tree, { + leave: function(node) { + var comment2; + while (cursor < comments.length) { + comment2 = comments[cursor]; + if (node.range[1] < comment2.extendedRange[0]) { + break; + } + if (node.range[1] === comment2.extendedRange[0]) { + if (!node.trailingComments) { + node.trailingComments = []; + } + node.trailingComments.push(comment2); + comments.splice(cursor, 1); + } else { + cursor += 1; + } + } + if (cursor === comments.length) { + return VisitorOption.Break; + } + if (comments[cursor].extendedRange[0] > node.range[1]) { + return VisitorOption.Skip; + } + } + }); + return tree; + } + exports2.Syntax = Syntax; + exports2.traverse = traverse; + exports2.replace = replace; + exports2.attachComments = attachComments; + exports2.VisitorKeys = VisitorKeys; + exports2.VisitorOption = VisitorOption; + exports2.Controller = Controller; + exports2.cloneEnvironment = function() { + return clone({}); + }; + return exports2; + })(exports); + } +}); + +// ../testeranto/node_modules/esutils/lib/ast.js +var require_ast = __commonJS({ + "../testeranto/node_modules/esutils/lib/ast.js"(exports, module) { + init_cjs_shim(); + (function() { + "use strict"; + function isExpression(node) { + if (node == null) { + return false; + } + switch (node.type) { + case "ArrayExpression": + case "AssignmentExpression": + case "BinaryExpression": + case "CallExpression": + case "ConditionalExpression": + case "FunctionExpression": + case "Identifier": + case "Literal": + case "LogicalExpression": + case "MemberExpression": + case "NewExpression": + case "ObjectExpression": + case "SequenceExpression": + case "ThisExpression": + case "UnaryExpression": + case "UpdateExpression": + return true; + } + return false; + } + function isIterationStatement(node) { + if (node == null) { + return false; + } + switch (node.type) { + case "DoWhileStatement": + case "ForInStatement": + case "ForStatement": + case "WhileStatement": + return true; + } + return false; + } + function isStatement(node) { + if (node == null) { + return false; + } + switch (node.type) { + case "BlockStatement": + case "BreakStatement": + case "ContinueStatement": + case "DebuggerStatement": + case "DoWhileStatement": + case "EmptyStatement": + case "ExpressionStatement": + case "ForInStatement": + case "ForStatement": + case "IfStatement": + case "LabeledStatement": + case "ReturnStatement": + case "SwitchStatement": + case "ThrowStatement": + case "TryStatement": + case "VariableDeclaration": + case "WhileStatement": + case "WithStatement": + return true; + } + return false; + } + function isSourceElement(node) { + return isStatement(node) || node != null && node.type === "FunctionDeclaration"; + } + function trailingStatement(node) { + switch (node.type) { + case "IfStatement": + if (node.alternate != null) { + return node.alternate; + } + return node.consequent; + case "LabeledStatement": + case "ForStatement": + case "ForInStatement": + case "WhileStatement": + case "WithStatement": + return node.body; + } + return null; + } + function isProblematicIfStatement(node) { + var current; + if (node.type !== "IfStatement") { + return false; + } + if (node.alternate == null) { + return false; + } + current = node.consequent; + do { + if (current.type === "IfStatement") { + if (current.alternate == null) { + return true; + } + } + current = trailingStatement(current); + } while (current); + return false; + } + module.exports = { + isExpression, + isStatement, + isIterationStatement, + isSourceElement, + isProblematicIfStatement, + trailingStatement + }; + })(); + } +}); + +// ../testeranto/node_modules/esutils/lib/code.js +var require_code = __commonJS({ + "../testeranto/node_modules/esutils/lib/code.js"(exports, module) { + init_cjs_shim(); + (function() { + "use strict"; + var ES6Regex, ES5Regex, NON_ASCII_WHITESPACES, IDENTIFIER_START, IDENTIFIER_PART, ch; + ES5Regex = { + // ECMAScript 5.1/Unicode v9.0.0 NonAsciiIdentifierStart: + NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/, + // ECMAScript 5.1/Unicode v9.0.0 NonAsciiIdentifierPart: + NonAsciiIdentifierPart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/ + }; + ES6Regex = { + // ECMAScript 6/Unicode v9.0.0 NonAsciiIdentifierStart: + NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/, + // ECMAScript 6/Unicode v9.0.0 NonAsciiIdentifierPart: + NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/ + }; + function isDecimalDigit(ch2) { + return 48 <= ch2 && ch2 <= 57; + } + function isHexDigit(ch2) { + return 48 <= ch2 && ch2 <= 57 || // 0..9 + 97 <= ch2 && ch2 <= 102 || // a..f + 65 <= ch2 && ch2 <= 70; + } + function isOctalDigit(ch2) { + return ch2 >= 48 && ch2 <= 55; + } + NON_ASCII_WHITESPACES = [ + 5760, + 8192, + 8193, + 8194, + 8195, + 8196, + 8197, + 8198, + 8199, + 8200, + 8201, + 8202, + 8239, + 8287, + 12288, + 65279 + ]; + function isWhiteSpace(ch2) { + return ch2 === 32 || ch2 === 9 || ch2 === 11 || ch2 === 12 || ch2 === 160 || ch2 >= 5760 && NON_ASCII_WHITESPACES.indexOf(ch2) >= 0; + } + function isLineTerminator(ch2) { + return ch2 === 10 || ch2 === 13 || ch2 === 8232 || ch2 === 8233; + } + function fromCodePoint(cp) { + if (cp <= 65535) { + return String.fromCharCode(cp); + } + var cu1 = String.fromCharCode(Math.floor((cp - 65536) / 1024) + 55296); + var cu2 = String.fromCharCode((cp - 65536) % 1024 + 56320); + return cu1 + cu2; + } + IDENTIFIER_START = new Array(128); + for (ch = 0; ch < 128; ++ch) { + IDENTIFIER_START[ch] = ch >= 97 && ch <= 122 || // a..z + ch >= 65 && ch <= 90 || // A..Z + ch === 36 || ch === 95; + } + IDENTIFIER_PART = new Array(128); + for (ch = 0; ch < 128; ++ch) { + IDENTIFIER_PART[ch] = ch >= 97 && ch <= 122 || // a..z + ch >= 65 && ch <= 90 || // A..Z + ch >= 48 && ch <= 57 || // 0..9 + ch === 36 || ch === 95; + } + function isIdentifierStartES5(ch2) { + return ch2 < 128 ? IDENTIFIER_START[ch2] : ES5Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch2)); + } + function isIdentifierPartES5(ch2) { + return ch2 < 128 ? IDENTIFIER_PART[ch2] : ES5Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch2)); + } + function isIdentifierStartES6(ch2) { + return ch2 < 128 ? IDENTIFIER_START[ch2] : ES6Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch2)); + } + function isIdentifierPartES6(ch2) { + return ch2 < 128 ? IDENTIFIER_PART[ch2] : ES6Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch2)); + } + module.exports = { + isDecimalDigit, + isHexDigit, + isOctalDigit, + isWhiteSpace, + isLineTerminator, + isIdentifierStartES5, + isIdentifierPartES5, + isIdentifierStartES6, + isIdentifierPartES6 + }; + })(); + } +}); + +// ../testeranto/node_modules/esutils/lib/keyword.js +var require_keyword = __commonJS({ + "../testeranto/node_modules/esutils/lib/keyword.js"(exports, module) { + init_cjs_shim(); + (function() { + "use strict"; + var code = require_code(); + function isStrictModeReservedWordES6(id) { + switch (id) { + case "implements": + case "interface": + case "package": + case "private": + case "protected": + case "public": + case "static": + case "let": + return true; + default: + return false; + } + } + function isKeywordES5(id, strict) { + if (!strict && id === "yield") { + return false; + } + return isKeywordES6(id, strict); + } + function isKeywordES6(id, strict) { + if (strict && isStrictModeReservedWordES6(id)) { + return true; + } + switch (id.length) { + case 2: + return id === "if" || id === "in" || id === "do"; + case 3: + return id === "var" || id === "for" || id === "new" || id === "try"; + case 4: + return id === "this" || id === "else" || id === "case" || id === "void" || id === "with" || id === "enum"; + case 5: + return id === "while" || id === "break" || id === "catch" || id === "throw" || id === "const" || id === "yield" || id === "class" || id === "super"; + case 6: + return id === "return" || id === "typeof" || id === "delete" || id === "switch" || id === "export" || id === "import"; + case 7: + return id === "default" || id === "finally" || id === "extends"; + case 8: + return id === "function" || id === "continue" || id === "debugger"; + case 10: + return id === "instanceof"; + default: + return false; + } + } + function isReservedWordES5(id, strict) { + return id === "null" || id === "true" || id === "false" || isKeywordES5(id, strict); + } + function isReservedWordES6(id, strict) { + return id === "null" || id === "true" || id === "false" || isKeywordES6(id, strict); + } + function isRestrictedWord(id) { + return id === "eval" || id === "arguments"; + } + function isIdentifierNameES5(id) { + var i, iz, ch; + if (id.length === 0) { + return false; + } + ch = id.charCodeAt(0); + if (!code.isIdentifierStartES5(ch)) { + return false; + } + for (i = 1, iz = id.length; i < iz; ++i) { + ch = id.charCodeAt(i); + if (!code.isIdentifierPartES5(ch)) { + return false; + } + } + return true; + } + function decodeUtf16(lead, trail) { + return (lead - 55296) * 1024 + (trail - 56320) + 65536; + } + function isIdentifierNameES6(id) { + var i, iz, ch, lowCh, check; + if (id.length === 0) { + return false; + } + check = code.isIdentifierStartES6; + for (i = 0, iz = id.length; i < iz; ++i) { + ch = id.charCodeAt(i); + if (55296 <= ch && ch <= 56319) { + ++i; + if (i >= iz) { + return false; + } + lowCh = id.charCodeAt(i); + if (!(56320 <= lowCh && lowCh <= 57343)) { + return false; + } + ch = decodeUtf16(ch, lowCh); + } + if (!check(ch)) { + return false; + } + check = code.isIdentifierPartES6; + } + return true; + } + function isIdentifierES5(id, strict) { + return isIdentifierNameES5(id) && !isReservedWordES5(id, strict); + } + function isIdentifierES6(id, strict) { + return isIdentifierNameES6(id) && !isReservedWordES6(id, strict); + } + module.exports = { + isKeywordES5, + isKeywordES6, + isReservedWordES5, + isReservedWordES6, + isRestrictedWord, + isIdentifierNameES5, + isIdentifierNameES6, + isIdentifierES5, + isIdentifierES6 + }; + })(); + } +}); + +// ../testeranto/node_modules/esutils/lib/utils.js +var require_utils5 = __commonJS({ + "../testeranto/node_modules/esutils/lib/utils.js"(exports) { + init_cjs_shim(); + (function() { + "use strict"; + exports.ast = require_ast(); + exports.code = require_code(); + exports.keyword = require_keyword(); + })(); + } +}); + +// ../testeranto/node_modules/source-map/lib/base64.js +var require_base64 = __commonJS({ + "../testeranto/node_modules/source-map/lib/base64.js"(exports) { + init_cjs_shim(); + var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(""); + exports.encode = function(number) { + if (0 <= number && number < intToCharMap.length) { + return intToCharMap[number]; + } + throw new TypeError("Must be between 0 and 63: " + number); + }; + exports.decode = function(charCode) { + var bigA = 65; + var bigZ = 90; + var littleA = 97; + var littleZ = 122; + var zero = 48; + var nine = 57; + var plus = 43; + var slash = 47; + var littleOffset = 26; + var numberOffset = 52; + if (bigA <= charCode && charCode <= bigZ) { + return charCode - bigA; + } + if (littleA <= charCode && charCode <= littleZ) { + return charCode - littleA + littleOffset; + } + if (zero <= charCode && charCode <= nine) { + return charCode - zero + numberOffset; + } + if (charCode == plus) { + return 62; + } + if (charCode == slash) { + return 63; + } + return -1; + }; + } +}); + +// ../testeranto/node_modules/source-map/lib/base64-vlq.js +var require_base64_vlq = __commonJS({ + "../testeranto/node_modules/source-map/lib/base64-vlq.js"(exports) { + init_cjs_shim(); + var base64 = require_base64(); + var VLQ_BASE_SHIFT = 5; + var VLQ_BASE = 1 << VLQ_BASE_SHIFT; + var VLQ_BASE_MASK = VLQ_BASE - 1; + var VLQ_CONTINUATION_BIT = VLQ_BASE; + function toVLQSigned(aValue) { + return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0; + } + function fromVLQSigned(aValue) { + var isNegative = (aValue & 1) === 1; + var shifted = aValue >> 1; + return isNegative ? -shifted : shifted; + } + exports.encode = function base64VLQ_encode(aValue) { + var encoded = ""; + var digit; + var vlq = toVLQSigned(aValue); + do { + digit = vlq & VLQ_BASE_MASK; + vlq >>>= VLQ_BASE_SHIFT; + if (vlq > 0) { + digit |= VLQ_CONTINUATION_BIT; + } + encoded += base64.encode(digit); + } while (vlq > 0); + return encoded; + }; + exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) { + var strLen = aStr.length; + var result = 0; + var shift = 0; + var continuation, digit; + do { + if (aIndex >= strLen) { + throw new Error("Expected more digits in base 64 VLQ value."); + } + digit = base64.decode(aStr.charCodeAt(aIndex++)); + if (digit === -1) { + throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1)); + } + continuation = !!(digit & VLQ_CONTINUATION_BIT); + digit &= VLQ_BASE_MASK; + result = result + (digit << shift); + shift += VLQ_BASE_SHIFT; + } while (continuation); + aOutParam.value = fromVLQSigned(result); + aOutParam.rest = aIndex; + }; + } +}); + +// ../testeranto/node_modules/source-map/lib/util.js +var require_util2 = __commonJS({ + "../testeranto/node_modules/source-map/lib/util.js"(exports) { + init_cjs_shim(); + function getArg(aArgs, aName, aDefaultValue) { + if (aName in aArgs) { + return aArgs[aName]; + } else if (arguments.length === 3) { + return aDefaultValue; + } else { + throw new Error('"' + aName + '" is a required argument.'); + } + } + exports.getArg = getArg; + var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/; + var dataUrlRegexp = /^data:.+\,.+$/; + function urlParse(aUrl) { + var match = aUrl.match(urlRegexp); + if (!match) { + return null; + } + return { + scheme: match[1], + auth: match[2], + host: match[3], + port: match[4], + path: match[5] + }; + } + exports.urlParse = urlParse; + function urlGenerate(aParsedUrl) { + var url = ""; + if (aParsedUrl.scheme) { + url += aParsedUrl.scheme + ":"; + } + url += "//"; + if (aParsedUrl.auth) { + url += aParsedUrl.auth + "@"; + } + if (aParsedUrl.host) { + url += aParsedUrl.host; + } + if (aParsedUrl.port) { + url += ":" + aParsedUrl.port; + } + if (aParsedUrl.path) { + url += aParsedUrl.path; + } + return url; + } + exports.urlGenerate = urlGenerate; + function normalize2(aPath) { + var path10 = aPath; + var url = urlParse(aPath); + if (url) { + if (!url.path) { + return aPath; + } + path10 = url.path; + } + var isAbsolute = exports.isAbsolute(path10); + var parts = path10.split(/\/+/); + for (var part, up = 0, i = parts.length - 1; i >= 0; i--) { + part = parts[i]; + if (part === ".") { + parts.splice(i, 1); + } else if (part === "..") { + up++; + } else if (up > 0) { + if (part === "") { + parts.splice(i + 1, up); + up = 0; + } else { + parts.splice(i, 2); + up--; + } + } + } + path10 = parts.join("/"); + if (path10 === "") { + path10 = isAbsolute ? "/" : "."; + } + if (url) { + url.path = path10; + return urlGenerate(url); + } + return path10; + } + exports.normalize = normalize2; + function join2(aRoot, aPath) { + if (aRoot === "") { + aRoot = "."; + } + if (aPath === "") { + aPath = "."; + } + var aPathUrl = urlParse(aPath); + var aRootUrl = urlParse(aRoot); + if (aRootUrl) { + aRoot = aRootUrl.path || "/"; + } + if (aPathUrl && !aPathUrl.scheme) { + if (aRootUrl) { + aPathUrl.scheme = aRootUrl.scheme; + } + return urlGenerate(aPathUrl); + } + if (aPathUrl || aPath.match(dataUrlRegexp)) { + return aPath; + } + if (aRootUrl && !aRootUrl.host && !aRootUrl.path) { + aRootUrl.host = aPath; + return urlGenerate(aRootUrl); + } + var joined = aPath.charAt(0) === "/" ? aPath : normalize2(aRoot.replace(/\/+$/, "") + "/" + aPath); + if (aRootUrl) { + aRootUrl.path = joined; + return urlGenerate(aRootUrl); + } + return joined; + } + exports.join = join2; + exports.isAbsolute = function(aPath) { + return aPath.charAt(0) === "/" || urlRegexp.test(aPath); + }; + function relative2(aRoot, aPath) { + if (aRoot === "") { + aRoot = "."; + } + aRoot = aRoot.replace(/\/$/, ""); + var level = 0; + while (aPath.indexOf(aRoot + "/") !== 0) { + var index = aRoot.lastIndexOf("/"); + if (index < 0) { + return aPath; + } + aRoot = aRoot.slice(0, index); + if (aRoot.match(/^([^\/]+:\/)?\/*$/)) { + return aPath; + } + ++level; + } + return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1); + } + exports.relative = relative2; + var supportsNullProto = function() { + var obj = /* @__PURE__ */ Object.create(null); + return !("__proto__" in obj); + }(); + function identity(s) { + return s; + } + function toSetString(aStr) { + if (isProtoString(aStr)) { + return "$" + aStr; + } + return aStr; + } + exports.toSetString = supportsNullProto ? identity : toSetString; + function fromSetString(aStr) { + if (isProtoString(aStr)) { + return aStr.slice(1); + } + return aStr; + } + exports.fromSetString = supportsNullProto ? identity : fromSetString; + function isProtoString(s) { + if (!s) { + return false; + } + var length = s.length; + if (length < 9) { + return false; + } + if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) { + return false; + } + for (var i = length - 10; i >= 0; i--) { + if (s.charCodeAt(i) !== 36) { + return false; + } + } + return true; + } + function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) { + var cmp = strcmp(mappingA.source, mappingB.source); + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalLine - mappingB.originalLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalColumn - mappingB.originalColumn; + if (cmp !== 0 || onlyCompareOriginal) { + return cmp; + } + cmp = mappingA.generatedColumn - mappingB.generatedColumn; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.generatedLine - mappingB.generatedLine; + if (cmp !== 0) { + return cmp; + } + return strcmp(mappingA.name, mappingB.name); + } + exports.compareByOriginalPositions = compareByOriginalPositions; + function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) { + var cmp = mappingA.generatedLine - mappingB.generatedLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.generatedColumn - mappingB.generatedColumn; + if (cmp !== 0 || onlyCompareGenerated) { + return cmp; + } + cmp = strcmp(mappingA.source, mappingB.source); + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalLine - mappingB.originalLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalColumn - mappingB.originalColumn; + if (cmp !== 0) { + return cmp; + } + return strcmp(mappingA.name, mappingB.name); + } + exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated; + function strcmp(aStr1, aStr2) { + if (aStr1 === aStr2) { + return 0; + } + if (aStr1 === null) { + return 1; + } + if (aStr2 === null) { + return -1; + } + if (aStr1 > aStr2) { + return 1; + } + return -1; + } + function compareByGeneratedPositionsInflated(mappingA, mappingB) { + var cmp = mappingA.generatedLine - mappingB.generatedLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.generatedColumn - mappingB.generatedColumn; + if (cmp !== 0) { + return cmp; + } + cmp = strcmp(mappingA.source, mappingB.source); + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalLine - mappingB.originalLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalColumn - mappingB.originalColumn; + if (cmp !== 0) { + return cmp; + } + return strcmp(mappingA.name, mappingB.name); + } + exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated; + function parseSourceMapInput(str) { + return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, "")); + } + exports.parseSourceMapInput = parseSourceMapInput; + function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) { + sourceURL = sourceURL || ""; + if (sourceRoot) { + if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") { + sourceRoot += "/"; + } + sourceURL = sourceRoot + sourceURL; + } + if (sourceMapURL) { + var parsed = urlParse(sourceMapURL); + if (!parsed) { + throw new Error("sourceMapURL could not be parsed"); + } + if (parsed.path) { + var index = parsed.path.lastIndexOf("/"); + if (index >= 0) { + parsed.path = parsed.path.substring(0, index + 1); + } + } + sourceURL = join2(urlGenerate(parsed), sourceURL); + } + return normalize2(sourceURL); + } + exports.computeSourceURL = computeSourceURL; + } +}); + +// ../testeranto/node_modules/source-map/lib/array-set.js +var require_array_set = __commonJS({ + "../testeranto/node_modules/source-map/lib/array-set.js"(exports) { + init_cjs_shim(); + var util2 = require_util2(); + var has = Object.prototype.hasOwnProperty; + var hasNativeMap = typeof Map !== "undefined"; + function ArraySet() { + this._array = []; + this._set = hasNativeMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ Object.create(null); + } + ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) { + var set = new ArraySet(); + for (var i = 0, len = aArray.length; i < len; i++) { + set.add(aArray[i], aAllowDuplicates); + } + return set; + }; + ArraySet.prototype.size = function ArraySet_size() { + return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length; + }; + ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) { + var sStr = hasNativeMap ? aStr : util2.toSetString(aStr); + var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr); + var idx = this._array.length; + if (!isDuplicate || aAllowDuplicates) { + this._array.push(aStr); + } + if (!isDuplicate) { + if (hasNativeMap) { + this._set.set(aStr, idx); + } else { + this._set[sStr] = idx; + } + } + }; + ArraySet.prototype.has = function ArraySet_has(aStr) { + if (hasNativeMap) { + return this._set.has(aStr); + } else { + var sStr = util2.toSetString(aStr); + return has.call(this._set, sStr); + } + }; + ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) { + if (hasNativeMap) { + var idx = this._set.get(aStr); + if (idx >= 0) { + return idx; + } + } else { + var sStr = util2.toSetString(aStr); + if (has.call(this._set, sStr)) { + return this._set[sStr]; + } + } + throw new Error('"' + aStr + '" is not in the set.'); + }; + ArraySet.prototype.at = function ArraySet_at(aIdx) { + if (aIdx >= 0 && aIdx < this._array.length) { + return this._array[aIdx]; + } + throw new Error("No element indexed by " + aIdx); + }; + ArraySet.prototype.toArray = function ArraySet_toArray() { + return this._array.slice(); + }; + exports.ArraySet = ArraySet; + } +}); + +// ../testeranto/node_modules/source-map/lib/mapping-list.js +var require_mapping_list = __commonJS({ + "../testeranto/node_modules/source-map/lib/mapping-list.js"(exports) { + init_cjs_shim(); + var util2 = require_util2(); + function generatedPositionAfter(mappingA, mappingB) { + var lineA = mappingA.generatedLine; + var lineB = mappingB.generatedLine; + var columnA = mappingA.generatedColumn; + var columnB = mappingB.generatedColumn; + return lineB > lineA || lineB == lineA && columnB >= columnA || util2.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0; + } + function MappingList() { + this._array = []; + this._sorted = true; + this._last = { generatedLine: -1, generatedColumn: 0 }; + } + MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) { + this._array.forEach(aCallback, aThisArg); + }; + MappingList.prototype.add = function MappingList_add(aMapping) { + if (generatedPositionAfter(this._last, aMapping)) { + this._last = aMapping; + this._array.push(aMapping); + } else { + this._sorted = false; + this._array.push(aMapping); + } + }; + MappingList.prototype.toArray = function MappingList_toArray() { + if (!this._sorted) { + this._array.sort(util2.compareByGeneratedPositionsInflated); + this._sorted = true; + } + return this._array; + }; + exports.MappingList = MappingList; + } +}); + +// ../testeranto/node_modules/source-map/lib/source-map-generator.js +var require_source_map_generator = __commonJS({ + "../testeranto/node_modules/source-map/lib/source-map-generator.js"(exports) { + init_cjs_shim(); + var base64VLQ = require_base64_vlq(); + var util2 = require_util2(); + var ArraySet = require_array_set().ArraySet; + var MappingList = require_mapping_list().MappingList; + function SourceMapGenerator(aArgs) { + if (!aArgs) { + aArgs = {}; + } + this._file = util2.getArg(aArgs, "file", null); + this._sourceRoot = util2.getArg(aArgs, "sourceRoot", null); + this._skipValidation = util2.getArg(aArgs, "skipValidation", false); + this._sources = new ArraySet(); + this._names = new ArraySet(); + this._mappings = new MappingList(); + this._sourcesContents = null; + } + SourceMapGenerator.prototype._version = 3; + SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) { + var sourceRoot = aSourceMapConsumer.sourceRoot; + var generator = new SourceMapGenerator({ + file: aSourceMapConsumer.file, + sourceRoot + }); + aSourceMapConsumer.eachMapping(function(mapping) { + var newMapping = { + generated: { + line: mapping.generatedLine, + column: mapping.generatedColumn + } + }; + if (mapping.source != null) { + newMapping.source = mapping.source; + if (sourceRoot != null) { + newMapping.source = util2.relative(sourceRoot, newMapping.source); + } + newMapping.original = { + line: mapping.originalLine, + column: mapping.originalColumn + }; + if (mapping.name != null) { + newMapping.name = mapping.name; + } + } + generator.addMapping(newMapping); + }); + aSourceMapConsumer.sources.forEach(function(sourceFile) { + var sourceRelative = sourceFile; + if (sourceRoot !== null) { + sourceRelative = util2.relative(sourceRoot, sourceFile); + } + if (!generator._sources.has(sourceRelative)) { + generator._sources.add(sourceRelative); + } + var content = aSourceMapConsumer.sourceContentFor(sourceFile); + if (content != null) { + generator.setSourceContent(sourceFile, content); + } + }); + return generator; + }; + SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) { + var generated = util2.getArg(aArgs, "generated"); + var original = util2.getArg(aArgs, "original", null); + var source = util2.getArg(aArgs, "source", null); + var name = util2.getArg(aArgs, "name", null); + if (!this._skipValidation) { + this._validateMapping(generated, original, source, name); + } + if (source != null) { + source = String(source); + if (!this._sources.has(source)) { + this._sources.add(source); + } + } + if (name != null) { + name = String(name); + if (!this._names.has(name)) { + this._names.add(name); + } + } + this._mappings.add({ + generatedLine: generated.line, + generatedColumn: generated.column, + originalLine: original != null && original.line, + originalColumn: original != null && original.column, + source, + name + }); + }; + SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) { + var source = aSourceFile; + if (this._sourceRoot != null) { + source = util2.relative(this._sourceRoot, source); + } + if (aSourceContent != null) { + if (!this._sourcesContents) { + this._sourcesContents = /* @__PURE__ */ Object.create(null); + } + this._sourcesContents[util2.toSetString(source)] = aSourceContent; + } else if (this._sourcesContents) { + delete this._sourcesContents[util2.toSetString(source)]; + if (Object.keys(this._sourcesContents).length === 0) { + this._sourcesContents = null; + } + } + }; + SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) { + var sourceFile = aSourceFile; + if (aSourceFile == null) { + if (aSourceMapConsumer.file == null) { + throw new Error( + `SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.` + ); + } + sourceFile = aSourceMapConsumer.file; + } + var sourceRoot = this._sourceRoot; + if (sourceRoot != null) { + sourceFile = util2.relative(sourceRoot, sourceFile); + } + var newSources = new ArraySet(); + var newNames = new ArraySet(); + this._mappings.unsortedForEach(function(mapping) { + if (mapping.source === sourceFile && mapping.originalLine != null) { + var original = aSourceMapConsumer.originalPositionFor({ + line: mapping.originalLine, + column: mapping.originalColumn + }); + if (original.source != null) { + mapping.source = original.source; + if (aSourceMapPath != null) { + mapping.source = util2.join(aSourceMapPath, mapping.source); + } + if (sourceRoot != null) { + mapping.source = util2.relative(sourceRoot, mapping.source); + } + mapping.originalLine = original.line; + mapping.originalColumn = original.column; + if (original.name != null) { + mapping.name = original.name; + } + } + } + var source = mapping.source; + if (source != null && !newSources.has(source)) { + newSources.add(source); + } + var name = mapping.name; + if (name != null && !newNames.has(name)) { + newNames.add(name); + } + }, this); + this._sources = newSources; + this._names = newNames; + aSourceMapConsumer.sources.forEach(function(sourceFile2) { + var content = aSourceMapConsumer.sourceContentFor(sourceFile2); + if (content != null) { + if (aSourceMapPath != null) { + sourceFile2 = util2.join(aSourceMapPath, sourceFile2); + } + if (sourceRoot != null) { + sourceFile2 = util2.relative(sourceRoot, sourceFile2); + } + this.setSourceContent(sourceFile2, content); + } + }, this); + }; + SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) { + if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") { + throw new Error( + "original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values." + ); + } + if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) { + return; + } else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) { + return; + } else { + throw new Error("Invalid mapping: " + JSON.stringify({ + generated: aGenerated, + source: aSource, + original: aOriginal, + name: aName + })); + } + }; + SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() { + var previousGeneratedColumn = 0; + var previousGeneratedLine = 1; + var previousOriginalColumn = 0; + var previousOriginalLine = 0; + var previousName = 0; + var previousSource = 0; + var result = ""; + var next; + var mapping; + var nameIdx; + var sourceIdx; + var mappings = this._mappings.toArray(); + for (var i = 0, len = mappings.length; i < len; i++) { + mapping = mappings[i]; + next = ""; + if (mapping.generatedLine !== previousGeneratedLine) { + previousGeneratedColumn = 0; + while (mapping.generatedLine !== previousGeneratedLine) { + next += ";"; + previousGeneratedLine++; + } + } else { + if (i > 0) { + if (!util2.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) { + continue; + } + next += ","; + } + } + next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn); + previousGeneratedColumn = mapping.generatedColumn; + if (mapping.source != null) { + sourceIdx = this._sources.indexOf(mapping.source); + next += base64VLQ.encode(sourceIdx - previousSource); + previousSource = sourceIdx; + next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine); + previousOriginalLine = mapping.originalLine - 1; + next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn); + previousOriginalColumn = mapping.originalColumn; + if (mapping.name != null) { + nameIdx = this._names.indexOf(mapping.name); + next += base64VLQ.encode(nameIdx - previousName); + previousName = nameIdx; + } + } + result += next; + } + return result; + }; + SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) { + return aSources.map(function(source) { + if (!this._sourcesContents) { + return null; + } + if (aSourceRoot != null) { + source = util2.relative(aSourceRoot, source); + } + var key = util2.toSetString(source); + return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null; + }, this); + }; + SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() { + var map2 = { + version: this._version, + sources: this._sources.toArray(), + names: this._names.toArray(), + mappings: this._serializeMappings() + }; + if (this._file != null) { + map2.file = this._file; + } + if (this._sourceRoot != null) { + map2.sourceRoot = this._sourceRoot; + } + if (this._sourcesContents) { + map2.sourcesContent = this._generateSourcesContent(map2.sources, map2.sourceRoot); + } + return map2; + }; + SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() { + return JSON.stringify(this.toJSON()); + }; + exports.SourceMapGenerator = SourceMapGenerator; + } +}); + +// ../testeranto/node_modules/source-map/lib/binary-search.js +var require_binary_search = __commonJS({ + "../testeranto/node_modules/source-map/lib/binary-search.js"(exports) { + init_cjs_shim(); + exports.GREATEST_LOWER_BOUND = 1; + exports.LEAST_UPPER_BOUND = 2; + function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) { + var mid = Math.floor((aHigh - aLow) / 2) + aLow; + var cmp = aCompare(aNeedle, aHaystack[mid], true); + if (cmp === 0) { + return mid; + } else if (cmp > 0) { + if (aHigh - mid > 1) { + return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias); + } + if (aBias == exports.LEAST_UPPER_BOUND) { + return aHigh < aHaystack.length ? aHigh : -1; + } else { + return mid; + } + } else { + if (mid - aLow > 1) { + return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias); + } + if (aBias == exports.LEAST_UPPER_BOUND) { + return mid; + } else { + return aLow < 0 ? -1 : aLow; + } + } + } + exports.search = function search(aNeedle, aHaystack, aCompare, aBias) { + if (aHaystack.length === 0) { + return -1; + } + var index = recursiveSearch( + -1, + aHaystack.length, + aNeedle, + aHaystack, + aCompare, + aBias || exports.GREATEST_LOWER_BOUND + ); + if (index < 0) { + return -1; + } + while (index - 1 >= 0) { + if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) { + break; + } + --index; + } + return index; + }; + } +}); + +// ../testeranto/node_modules/source-map/lib/quick-sort.js +var require_quick_sort = __commonJS({ + "../testeranto/node_modules/source-map/lib/quick-sort.js"(exports) { + init_cjs_shim(); + function swap(ary, x, y) { + var temp = ary[x]; + ary[x] = ary[y]; + ary[y] = temp; + } + function randomIntInRange(low, high) { + return Math.round(low + Math.random() * (high - low)); + } + function doQuickSort(ary, comparator, p, r) { + if (p < r) { + var pivotIndex = randomIntInRange(p, r); + var i = p - 1; + swap(ary, pivotIndex, r); + var pivot = ary[r]; + for (var j = p; j < r; j++) { + if (comparator(ary[j], pivot) <= 0) { + i += 1; + swap(ary, i, j); + } + } + swap(ary, i + 1, j); + var q = i + 1; + doQuickSort(ary, comparator, p, q - 1); + doQuickSort(ary, comparator, q + 1, r); + } + } + exports.quickSort = function(ary, comparator) { + doQuickSort(ary, comparator, 0, ary.length - 1); + }; + } +}); + +// ../testeranto/node_modules/source-map/lib/source-map-consumer.js +var require_source_map_consumer = __commonJS({ + "../testeranto/node_modules/source-map/lib/source-map-consumer.js"(exports) { + init_cjs_shim(); + var util2 = require_util2(); + var binarySearch = require_binary_search(); + var ArraySet = require_array_set().ArraySet; + var base64VLQ = require_base64_vlq(); + var quickSort = require_quick_sort().quickSort; + function SourceMapConsumer(aSourceMap, aSourceMapURL) { + var sourceMap = aSourceMap; + if (typeof aSourceMap === "string") { + sourceMap = util2.parseSourceMapInput(aSourceMap); + } + return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL); + } + SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) { + return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL); + }; + SourceMapConsumer.prototype._version = 3; + SourceMapConsumer.prototype.__generatedMappings = null; + Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", { + configurable: true, + enumerable: true, + get: function() { + if (!this.__generatedMappings) { + this._parseMappings(this._mappings, this.sourceRoot); + } + return this.__generatedMappings; + } + }); + SourceMapConsumer.prototype.__originalMappings = null; + Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", { + configurable: true, + enumerable: true, + get: function() { + if (!this.__originalMappings) { + this._parseMappings(this._mappings, this.sourceRoot); + } + return this.__originalMappings; + } + }); + SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) { + var c = aStr.charAt(index); + return c === ";" || c === ","; + }; + SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) { + throw new Error("Subclasses must implement _parseMappings"); + }; + SourceMapConsumer.GENERATED_ORDER = 1; + SourceMapConsumer.ORIGINAL_ORDER = 2; + SourceMapConsumer.GREATEST_LOWER_BOUND = 1; + SourceMapConsumer.LEAST_UPPER_BOUND = 2; + SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) { + var context = aContext || null; + var order = aOrder || SourceMapConsumer.GENERATED_ORDER; + var mappings; + switch (order) { + case SourceMapConsumer.GENERATED_ORDER: + mappings = this._generatedMappings; + break; + case SourceMapConsumer.ORIGINAL_ORDER: + mappings = this._originalMappings; + break; + default: + throw new Error("Unknown order of iteration."); + } + var sourceRoot = this.sourceRoot; + mappings.map(function(mapping) { + var source = mapping.source === null ? null : this._sources.at(mapping.source); + source = util2.computeSourceURL(sourceRoot, source, this._sourceMapURL); + return { + source, + generatedLine: mapping.generatedLine, + generatedColumn: mapping.generatedColumn, + originalLine: mapping.originalLine, + originalColumn: mapping.originalColumn, + name: mapping.name === null ? null : this._names.at(mapping.name) + }; + }, this).forEach(aCallback, context); + }; + SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) { + var line = util2.getArg(aArgs, "line"); + var needle = { + source: util2.getArg(aArgs, "source"), + originalLine: line, + originalColumn: util2.getArg(aArgs, "column", 0) + }; + needle.source = this._findSourceIndex(needle.source); + if (needle.source < 0) { + return []; + } + var mappings = []; + var index = this._findMapping( + needle, + this._originalMappings, + "originalLine", + "originalColumn", + util2.compareByOriginalPositions, + binarySearch.LEAST_UPPER_BOUND + ); + if (index >= 0) { + var mapping = this._originalMappings[index]; + if (aArgs.column === void 0) { + var originalLine = mapping.originalLine; + while (mapping && mapping.originalLine === originalLine) { + mappings.push({ + line: util2.getArg(mapping, "generatedLine", null), + column: util2.getArg(mapping, "generatedColumn", null), + lastColumn: util2.getArg(mapping, "lastGeneratedColumn", null) + }); + mapping = this._originalMappings[++index]; + } + } else { + var originalColumn = mapping.originalColumn; + while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) { + mappings.push({ + line: util2.getArg(mapping, "generatedLine", null), + column: util2.getArg(mapping, "generatedColumn", null), + lastColumn: util2.getArg(mapping, "lastGeneratedColumn", null) + }); + mapping = this._originalMappings[++index]; + } + } + } + return mappings; + }; + exports.SourceMapConsumer = SourceMapConsumer; + function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) { + var sourceMap = aSourceMap; + if (typeof aSourceMap === "string") { + sourceMap = util2.parseSourceMapInput(aSourceMap); + } + var version2 = util2.getArg(sourceMap, "version"); + var sources = util2.getArg(sourceMap, "sources"); + var names = util2.getArg(sourceMap, "names", []); + var sourceRoot = util2.getArg(sourceMap, "sourceRoot", null); + var sourcesContent = util2.getArg(sourceMap, "sourcesContent", null); + var mappings = util2.getArg(sourceMap, "mappings"); + var file = util2.getArg(sourceMap, "file", null); + if (version2 != this._version) { + throw new Error("Unsupported version: " + version2); + } + if (sourceRoot) { + sourceRoot = util2.normalize(sourceRoot); + } + sources = sources.map(String).map(util2.normalize).map(function(source) { + return sourceRoot && util2.isAbsolute(sourceRoot) && util2.isAbsolute(source) ? util2.relative(sourceRoot, source) : source; + }); + this._names = ArraySet.fromArray(names.map(String), true); + this._sources = ArraySet.fromArray(sources, true); + this._absoluteSources = this._sources.toArray().map(function(s) { + return util2.computeSourceURL(sourceRoot, s, aSourceMapURL); + }); + this.sourceRoot = sourceRoot; + this.sourcesContent = sourcesContent; + this._mappings = mappings; + this._sourceMapURL = aSourceMapURL; + this.file = file; + } + BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype); + BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer; + BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) { + var relativeSource = aSource; + if (this.sourceRoot != null) { + relativeSource = util2.relative(this.sourceRoot, relativeSource); + } + if (this._sources.has(relativeSource)) { + return this._sources.indexOf(relativeSource); + } + var i; + for (i = 0; i < this._absoluteSources.length; ++i) { + if (this._absoluteSources[i] == aSource) { + return i; + } + } + return -1; + }; + BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) { + var smc = Object.create(BasicSourceMapConsumer.prototype); + var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true); + var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true); + smc.sourceRoot = aSourceMap._sourceRoot; + smc.sourcesContent = aSourceMap._generateSourcesContent( + smc._sources.toArray(), + smc.sourceRoot + ); + smc.file = aSourceMap._file; + smc._sourceMapURL = aSourceMapURL; + smc._absoluteSources = smc._sources.toArray().map(function(s) { + return util2.computeSourceURL(smc.sourceRoot, s, aSourceMapURL); + }); + var generatedMappings = aSourceMap._mappings.toArray().slice(); + var destGeneratedMappings = smc.__generatedMappings = []; + var destOriginalMappings = smc.__originalMappings = []; + for (var i = 0, length = generatedMappings.length; i < length; i++) { + var srcMapping = generatedMappings[i]; + var destMapping = new Mapping(); + destMapping.generatedLine = srcMapping.generatedLine; + destMapping.generatedColumn = srcMapping.generatedColumn; + if (srcMapping.source) { + destMapping.source = sources.indexOf(srcMapping.source); + destMapping.originalLine = srcMapping.originalLine; + destMapping.originalColumn = srcMapping.originalColumn; + if (srcMapping.name) { + destMapping.name = names.indexOf(srcMapping.name); + } + destOriginalMappings.push(destMapping); + } + destGeneratedMappings.push(destMapping); + } + quickSort(smc.__originalMappings, util2.compareByOriginalPositions); + return smc; + }; + BasicSourceMapConsumer.prototype._version = 3; + Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", { + get: function() { + return this._absoluteSources.slice(); + } + }); + function Mapping() { + this.generatedLine = 0; + this.generatedColumn = 0; + this.source = null; + this.originalLine = null; + this.originalColumn = null; + this.name = null; + } + BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) { + var generatedLine = 1; + var previousGeneratedColumn = 0; + var previousOriginalLine = 0; + var previousOriginalColumn = 0; + var previousSource = 0; + var previousName = 0; + var length = aStr.length; + var index = 0; + var cachedSegments = {}; + var temp = {}; + var originalMappings = []; + var generatedMappings = []; + var mapping, str, segment, end, value; + while (index < length) { + if (aStr.charAt(index) === ";") { + generatedLine++; + index++; + previousGeneratedColumn = 0; + } else if (aStr.charAt(index) === ",") { + index++; + } else { + mapping = new Mapping(); + mapping.generatedLine = generatedLine; + for (end = index; end < length; end++) { + if (this._charIsMappingSeparator(aStr, end)) { + break; + } + } + str = aStr.slice(index, end); + segment = cachedSegments[str]; + if (segment) { + index += str.length; + } else { + segment = []; + while (index < end) { + base64VLQ.decode(aStr, index, temp); + value = temp.value; + index = temp.rest; + segment.push(value); + } + if (segment.length === 2) { + throw new Error("Found a source, but no line and column"); + } + if (segment.length === 3) { + throw new Error("Found a source and line, but no column"); + } + cachedSegments[str] = segment; + } + mapping.generatedColumn = previousGeneratedColumn + segment[0]; + previousGeneratedColumn = mapping.generatedColumn; + if (segment.length > 1) { + mapping.source = previousSource + segment[1]; + previousSource += segment[1]; + mapping.originalLine = previousOriginalLine + segment[2]; + previousOriginalLine = mapping.originalLine; + mapping.originalLine += 1; + mapping.originalColumn = previousOriginalColumn + segment[3]; + previousOriginalColumn = mapping.originalColumn; + if (segment.length > 4) { + mapping.name = previousName + segment[4]; + previousName += segment[4]; + } + } + generatedMappings.push(mapping); + if (typeof mapping.originalLine === "number") { + originalMappings.push(mapping); + } + } + } + quickSort(generatedMappings, util2.compareByGeneratedPositionsDeflated); + this.__generatedMappings = generatedMappings; + quickSort(originalMappings, util2.compareByOriginalPositions); + this.__originalMappings = originalMappings; + }; + BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) { + if (aNeedle[aLineName] <= 0) { + throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]); + } + if (aNeedle[aColumnName] < 0) { + throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]); + } + return binarySearch.search(aNeedle, aMappings, aComparator, aBias); + }; + BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() { + for (var index = 0; index < this._generatedMappings.length; ++index) { + var mapping = this._generatedMappings[index]; + if (index + 1 < this._generatedMappings.length) { + var nextMapping = this._generatedMappings[index + 1]; + if (mapping.generatedLine === nextMapping.generatedLine) { + mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1; + continue; + } + } + mapping.lastGeneratedColumn = Infinity; + } + }; + BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) { + var needle = { + generatedLine: util2.getArg(aArgs, "line"), + generatedColumn: util2.getArg(aArgs, "column") + }; + var index = this._findMapping( + needle, + this._generatedMappings, + "generatedLine", + "generatedColumn", + util2.compareByGeneratedPositionsDeflated, + util2.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND) + ); + if (index >= 0) { + var mapping = this._generatedMappings[index]; + if (mapping.generatedLine === needle.generatedLine) { + var source = util2.getArg(mapping, "source", null); + if (source !== null) { + source = this._sources.at(source); + source = util2.computeSourceURL(this.sourceRoot, source, this._sourceMapURL); + } + var name = util2.getArg(mapping, "name", null); + if (name !== null) { + name = this._names.at(name); + } + return { + source, + line: util2.getArg(mapping, "originalLine", null), + column: util2.getArg(mapping, "originalColumn", null), + name + }; + } + } + return { + source: null, + line: null, + column: null, + name: null + }; + }; + BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() { + if (!this.sourcesContent) { + return false; + } + return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) { + return sc == null; + }); + }; + BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) { + if (!this.sourcesContent) { + return null; + } + var index = this._findSourceIndex(aSource); + if (index >= 0) { + return this.sourcesContent[index]; + } + var relativeSource = aSource; + if (this.sourceRoot != null) { + relativeSource = util2.relative(this.sourceRoot, relativeSource); + } + var url; + if (this.sourceRoot != null && (url = util2.urlParse(this.sourceRoot))) { + var fileUriAbsPath = relativeSource.replace(/^file:\/\//, ""); + if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) { + return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]; + } + if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) { + return this.sourcesContent[this._sources.indexOf("/" + relativeSource)]; + } + } + if (nullOnMissing) { + return null; + } else { + throw new Error('"' + relativeSource + '" is not in the SourceMap.'); + } + }; + BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) { + var source = util2.getArg(aArgs, "source"); + source = this._findSourceIndex(source); + if (source < 0) { + return { + line: null, + column: null, + lastColumn: null + }; + } + var needle = { + source, + originalLine: util2.getArg(aArgs, "line"), + originalColumn: util2.getArg(aArgs, "column") + }; + var index = this._findMapping( + needle, + this._originalMappings, + "originalLine", + "originalColumn", + util2.compareByOriginalPositions, + util2.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND) + ); + if (index >= 0) { + var mapping = this._originalMappings[index]; + if (mapping.source === needle.source) { + return { + line: util2.getArg(mapping, "generatedLine", null), + column: util2.getArg(mapping, "generatedColumn", null), + lastColumn: util2.getArg(mapping, "lastGeneratedColumn", null) + }; + } + } + return { + line: null, + column: null, + lastColumn: null + }; + }; + exports.BasicSourceMapConsumer = BasicSourceMapConsumer; + function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) { + var sourceMap = aSourceMap; + if (typeof aSourceMap === "string") { + sourceMap = util2.parseSourceMapInput(aSourceMap); + } + var version2 = util2.getArg(sourceMap, "version"); + var sections = util2.getArg(sourceMap, "sections"); + if (version2 != this._version) { + throw new Error("Unsupported version: " + version2); + } + this._sources = new ArraySet(); + this._names = new ArraySet(); + var lastOffset = { + line: -1, + column: 0 + }; + this._sections = sections.map(function(s) { + if (s.url) { + throw new Error("Support for url field in sections not implemented."); + } + var offset = util2.getArg(s, "offset"); + var offsetLine = util2.getArg(offset, "line"); + var offsetColumn = util2.getArg(offset, "column"); + if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) { + throw new Error("Section offsets must be ordered and non-overlapping."); + } + lastOffset = offset; + return { + generatedOffset: { + // The offset fields are 0-based, but we use 1-based indices when + // encoding/decoding from VLQ. + generatedLine: offsetLine + 1, + generatedColumn: offsetColumn + 1 + }, + consumer: new SourceMapConsumer(util2.getArg(s, "map"), aSourceMapURL) + }; + }); + } + IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype); + IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer; + IndexedSourceMapConsumer.prototype._version = 3; + Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", { + get: function() { + var sources = []; + for (var i = 0; i < this._sections.length; i++) { + for (var j = 0; j < this._sections[i].consumer.sources.length; j++) { + sources.push(this._sections[i].consumer.sources[j]); + } + } + return sources; + } + }); + IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) { + var needle = { + generatedLine: util2.getArg(aArgs, "line"), + generatedColumn: util2.getArg(aArgs, "column") + }; + var sectionIndex = binarySearch.search( + needle, + this._sections, + function(needle2, section2) { + var cmp = needle2.generatedLine - section2.generatedOffset.generatedLine; + if (cmp) { + return cmp; + } + return needle2.generatedColumn - section2.generatedOffset.generatedColumn; + } + ); + var section = this._sections[sectionIndex]; + if (!section) { + return { + source: null, + line: null, + column: null, + name: null + }; + } + return section.consumer.originalPositionFor({ + line: needle.generatedLine - (section.generatedOffset.generatedLine - 1), + column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0), + bias: aArgs.bias + }); + }; + IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() { + return this._sections.every(function(s) { + return s.consumer.hasContentsOfAllSources(); + }); + }; + IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) { + for (var i = 0; i < this._sections.length; i++) { + var section = this._sections[i]; + var content = section.consumer.sourceContentFor(aSource, true); + if (content) { + return content; + } + } + if (nullOnMissing) { + return null; + } else { + throw new Error('"' + aSource + '" is not in the SourceMap.'); + } + }; + IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) { + for (var i = 0; i < this._sections.length; i++) { + var section = this._sections[i]; + if (section.consumer._findSourceIndex(util2.getArg(aArgs, "source")) === -1) { + continue; + } + var generatedPosition = section.consumer.generatedPositionFor(aArgs); + if (generatedPosition) { + var ret = { + line: generatedPosition.line + (section.generatedOffset.generatedLine - 1), + column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0) + }; + return ret; + } + } + return { + line: null, + column: null + }; + }; + IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) { + this.__generatedMappings = []; + this.__originalMappings = []; + for (var i = 0; i < this._sections.length; i++) { + var section = this._sections[i]; + var sectionMappings = section.consumer._generatedMappings; + for (var j = 0; j < sectionMappings.length; j++) { + var mapping = sectionMappings[j]; + var source = section.consumer._sources.at(mapping.source); + source = util2.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL); + this._sources.add(source); + source = this._sources.indexOf(source); + var name = null; + if (mapping.name) { + name = section.consumer._names.at(mapping.name); + this._names.add(name); + name = this._names.indexOf(name); + } + var adjustedMapping = { + source, + generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1), + generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0), + originalLine: mapping.originalLine, + originalColumn: mapping.originalColumn, + name + }; + this.__generatedMappings.push(adjustedMapping); + if (typeof adjustedMapping.originalLine === "number") { + this.__originalMappings.push(adjustedMapping); + } + } + } + quickSort(this.__generatedMappings, util2.compareByGeneratedPositionsDeflated); + quickSort(this.__originalMappings, util2.compareByOriginalPositions); + }; + exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer; + } +}); + +// ../testeranto/node_modules/source-map/lib/source-node.js +var require_source_node = __commonJS({ + "../testeranto/node_modules/source-map/lib/source-node.js"(exports) { + init_cjs_shim(); + var SourceMapGenerator = require_source_map_generator().SourceMapGenerator; + var util2 = require_util2(); + var REGEX_NEWLINE = /(\r?\n)/; + var NEWLINE_CODE = 10; + var isSourceNode = "$$$isSourceNode$$$"; + function SourceNode(aLine, aColumn, aSource, aChunks, aName) { + this.children = []; + this.sourceContents = {}; + this.line = aLine == null ? null : aLine; + this.column = aColumn == null ? null : aColumn; + this.source = aSource == null ? null : aSource; + this.name = aName == null ? null : aName; + this[isSourceNode] = true; + if (aChunks != null) + this.add(aChunks); + } + SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) { + var node = new SourceNode(); + var remainingLines = aGeneratedCode.split(REGEX_NEWLINE); + var remainingLinesIndex = 0; + var shiftNextLine = function() { + var lineContents = getNextLine(); + var newLine = getNextLine() || ""; + return lineContents + newLine; + function getNextLine() { + return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : void 0; + } + }; + var lastGeneratedLine = 1, lastGeneratedColumn = 0; + var lastMapping = null; + aSourceMapConsumer.eachMapping(function(mapping) { + if (lastMapping !== null) { + if (lastGeneratedLine < mapping.generatedLine) { + addMappingWithCode(lastMapping, shiftNextLine()); + lastGeneratedLine++; + lastGeneratedColumn = 0; + } else { + var nextLine = remainingLines[remainingLinesIndex] || ""; + var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn); + remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn); + lastGeneratedColumn = mapping.generatedColumn; + addMappingWithCode(lastMapping, code); + lastMapping = mapping; + return; + } + } + while (lastGeneratedLine < mapping.generatedLine) { + node.add(shiftNextLine()); + lastGeneratedLine++; + } + if (lastGeneratedColumn < mapping.generatedColumn) { + var nextLine = remainingLines[remainingLinesIndex] || ""; + node.add(nextLine.substr(0, mapping.generatedColumn)); + remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn); + lastGeneratedColumn = mapping.generatedColumn; + } + lastMapping = mapping; + }, this); + if (remainingLinesIndex < remainingLines.length) { + if (lastMapping) { + addMappingWithCode(lastMapping, shiftNextLine()); + } + node.add(remainingLines.splice(remainingLinesIndex).join("")); + } + aSourceMapConsumer.sources.forEach(function(sourceFile) { + var content = aSourceMapConsumer.sourceContentFor(sourceFile); + if (content != null) { + if (aRelativePath != null) { + sourceFile = util2.join(aRelativePath, sourceFile); + } + node.setSourceContent(sourceFile, content); + } + }); + return node; + function addMappingWithCode(mapping, code) { + if (mapping === null || mapping.source === void 0) { + node.add(code); + } else { + var source = aRelativePath ? util2.join(aRelativePath, mapping.source) : mapping.source; + node.add(new SourceNode( + mapping.originalLine, + mapping.originalColumn, + source, + code, + mapping.name + )); + } + } + }; + SourceNode.prototype.add = function SourceNode_add(aChunk) { + if (Array.isArray(aChunk)) { + aChunk.forEach(function(chunk) { + this.add(chunk); + }, this); + } else if (aChunk[isSourceNode] || typeof aChunk === "string") { + if (aChunk) { + this.children.push(aChunk); + } + } else { + throw new TypeError( + "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk + ); + } + return this; + }; + SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) { + if (Array.isArray(aChunk)) { + for (var i = aChunk.length - 1; i >= 0; i--) { + this.prepend(aChunk[i]); + } + } else if (aChunk[isSourceNode] || typeof aChunk === "string") { + this.children.unshift(aChunk); + } else { + throw new TypeError( + "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk + ); + } + return this; + }; + SourceNode.prototype.walk = function SourceNode_walk(aFn) { + var chunk; + for (var i = 0, len = this.children.length; i < len; i++) { + chunk = this.children[i]; + if (chunk[isSourceNode]) { + chunk.walk(aFn); + } else { + if (chunk !== "") { + aFn(chunk, { + source: this.source, + line: this.line, + column: this.column, + name: this.name + }); + } + } + } + }; + SourceNode.prototype.join = function SourceNode_join(aSep) { + var newChildren; + var i; + var len = this.children.length; + if (len > 0) { + newChildren = []; + for (i = 0; i < len - 1; i++) { + newChildren.push(this.children[i]); + newChildren.push(aSep); + } + newChildren.push(this.children[i]); + this.children = newChildren; + } + return this; + }; + SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) { + var lastChild = this.children[this.children.length - 1]; + if (lastChild[isSourceNode]) { + lastChild.replaceRight(aPattern, aReplacement); + } else if (typeof lastChild === "string") { + this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement); + } else { + this.children.push("".replace(aPattern, aReplacement)); + } + return this; + }; + SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) { + this.sourceContents[util2.toSetString(aSourceFile)] = aSourceContent; + }; + SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) { + for (var i = 0, len = this.children.length; i < len; i++) { + if (this.children[i][isSourceNode]) { + this.children[i].walkSourceContents(aFn); + } + } + var sources = Object.keys(this.sourceContents); + for (var i = 0, len = sources.length; i < len; i++) { + aFn(util2.fromSetString(sources[i]), this.sourceContents[sources[i]]); + } + }; + SourceNode.prototype.toString = function SourceNode_toString() { + var str = ""; + this.walk(function(chunk) { + str += chunk; + }); + return str; + }; + SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) { + var generated = { + code: "", + line: 1, + column: 0 + }; + var map2 = new SourceMapGenerator(aArgs); + var sourceMappingActive = false; + var lastOriginalSource = null; + var lastOriginalLine = null; + var lastOriginalColumn = null; + var lastOriginalName = null; + this.walk(function(chunk, original) { + generated.code += chunk; + if (original.source !== null && original.line !== null && original.column !== null) { + if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) { + map2.addMapping({ + source: original.source, + original: { + line: original.line, + column: original.column + }, + generated: { + line: generated.line, + column: generated.column + }, + name: original.name + }); + } + lastOriginalSource = original.source; + lastOriginalLine = original.line; + lastOriginalColumn = original.column; + lastOriginalName = original.name; + sourceMappingActive = true; + } else if (sourceMappingActive) { + map2.addMapping({ + generated: { + line: generated.line, + column: generated.column + } + }); + lastOriginalSource = null; + sourceMappingActive = false; + } + for (var idx = 0, length = chunk.length; idx < length; idx++) { + if (chunk.charCodeAt(idx) === NEWLINE_CODE) { + generated.line++; + generated.column = 0; + if (idx + 1 === length) { + lastOriginalSource = null; + sourceMappingActive = false; + } else if (sourceMappingActive) { + map2.addMapping({ + source: original.source, + original: { + line: original.line, + column: original.column + }, + generated: { + line: generated.line, + column: generated.column + }, + name: original.name + }); + } + } else { + generated.column++; + } + } + }); + this.walkSourceContents(function(sourceFile, sourceContent) { + map2.setSourceContent(sourceFile, sourceContent); + }); + return { code: generated.code, map: map2 }; + }; + exports.SourceNode = SourceNode; + } +}); + +// ../testeranto/node_modules/source-map/source-map.js +var require_source_map = __commonJS({ + "../testeranto/node_modules/source-map/source-map.js"(exports) { + init_cjs_shim(); + exports.SourceMapGenerator = require_source_map_generator().SourceMapGenerator; + exports.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer; + exports.SourceNode = require_source_node().SourceNode; + } +}); + +// ../testeranto/node_modules/escodegen/package.json +var require_package = __commonJS({ + "../testeranto/node_modules/escodegen/package.json"(exports, module) { + module.exports = { + name: "escodegen", + description: "ECMAScript code generator", + homepage: "http://github.com/estools/escodegen", + main: "escodegen.js", + bin: { + esgenerate: "./bin/esgenerate.js", + escodegen: "./bin/escodegen.js" + }, + files: [ + "LICENSE.BSD", + "README.md", + "bin", + "escodegen.js", + "package.json" + ], + version: "2.1.0", + engines: { + node: ">=6.0" + }, + maintainers: [ + { + name: "Yusuke Suzuki", + email: "utatane.tea@gmail.com", + web: "http://github.com/Constellation" + } + ], + repository: { + type: "git", + url: "http://github.com/estools/escodegen.git" + }, + dependencies: { + estraverse: "^5.2.0", + esutils: "^2.0.2", + esprima: "^4.0.1" + }, + optionalDependencies: { + "source-map": "~0.6.1" + }, + devDependencies: { + acorn: "^8.0.4", + bluebird: "^3.4.7", + "bower-registry-client": "^1.0.0", + chai: "^4.2.0", + "chai-exclude": "^2.0.2", + "commonjs-everywhere": "^0.9.7", + gulp: "^4.0.2", + "gulp-eslint": "^6.0.0", + "gulp-mocha": "^7.0.2", + minimist: "^1.2.5", + optionator: "^0.9.1", + semver: "^7.3.4" + }, + license: "BSD-2-Clause", + scripts: { + test: "gulp travis", + "unit-test": "gulp test", + lint: "gulp lint", + release: "node tools/release.js", + "build-min": "./node_modules/.bin/cjsify -ma path: tools/entry-point.js > escodegen.browser.min.js", + build: "./node_modules/.bin/cjsify -a path: tools/entry-point.js > escodegen.browser.js" + } + }; + } +}); + +// ../testeranto/node_modules/escodegen/escodegen.js +var require_escodegen = __commonJS({ + "../testeranto/node_modules/escodegen/escodegen.js"(exports) { + init_cjs_shim(); + (function() { + "use strict"; + var Syntax, Precedence, BinaryPrecedence, SourceNode, estraverse, esutils, base, indent, json, renumber, hexadecimal, quotes, escapeless, newline, space, parentheses, semicolons, safeConcatenation, directive, extra, parse, sourceMap, sourceCode, preserveBlankLines, FORMAT_MINIFY, FORMAT_DEFAULTS; + estraverse = require_estraverse(); + esutils = require_utils5(); + Syntax = estraverse.Syntax; + function isExpression(node) { + return CodeGenerator.Expression.hasOwnProperty(node.type); + } + function isStatement(node) { + return CodeGenerator.Statement.hasOwnProperty(node.type); + } + Precedence = { + Sequence: 0, + Yield: 1, + Assignment: 1, + Conditional: 2, + ArrowFunction: 2, + Coalesce: 3, + LogicalOR: 4, + LogicalAND: 5, + BitwiseOR: 6, + BitwiseXOR: 7, + BitwiseAND: 8, + Equality: 9, + Relational: 10, + BitwiseSHIFT: 11, + Additive: 12, + Multiplicative: 13, + Exponentiation: 14, + Await: 15, + Unary: 15, + Postfix: 16, + OptionalChaining: 17, + Call: 18, + New: 19, + TaggedTemplate: 20, + Member: 21, + Primary: 22 + }; + BinaryPrecedence = { + "??": Precedence.Coalesce, + "||": Precedence.LogicalOR, + "&&": Precedence.LogicalAND, + "|": Precedence.BitwiseOR, + "^": Precedence.BitwiseXOR, + "&": Precedence.BitwiseAND, + "==": Precedence.Equality, + "!=": Precedence.Equality, + "===": Precedence.Equality, + "!==": Precedence.Equality, + "is": Precedence.Equality, + "isnt": Precedence.Equality, + "<": Precedence.Relational, + ">": Precedence.Relational, + "<=": Precedence.Relational, + ">=": Precedence.Relational, + "in": Precedence.Relational, + "instanceof": Precedence.Relational, + "<<": Precedence.BitwiseSHIFT, + ">>": Precedence.BitwiseSHIFT, + ">>>": Precedence.BitwiseSHIFT, + "+": Precedence.Additive, + "-": Precedence.Additive, + "*": Precedence.Multiplicative, + "%": Precedence.Multiplicative, + "/": Precedence.Multiplicative, + "**": Precedence.Exponentiation + }; + var F_ALLOW_IN = 1, F_ALLOW_CALL = 1 << 1, F_ALLOW_UNPARATH_NEW = 1 << 2, F_FUNC_BODY = 1 << 3, F_DIRECTIVE_CTX = 1 << 4, F_SEMICOLON_OPT = 1 << 5, F_FOUND_COALESCE = 1 << 6; + var E_FTT = F_ALLOW_CALL | F_ALLOW_UNPARATH_NEW, E_TTF = F_ALLOW_IN | F_ALLOW_CALL, E_TTT = F_ALLOW_IN | F_ALLOW_CALL | F_ALLOW_UNPARATH_NEW, E_TFF = F_ALLOW_IN, E_FFT = F_ALLOW_UNPARATH_NEW, E_TFT = F_ALLOW_IN | F_ALLOW_UNPARATH_NEW; + var S_TFFF = F_ALLOW_IN, S_TFFT = F_ALLOW_IN | F_SEMICOLON_OPT, S_FFFF = 0, S_TFTF = F_ALLOW_IN | F_DIRECTIVE_CTX, S_TTFF = F_ALLOW_IN | F_FUNC_BODY; + function getDefaultOptions() { + return { + indent: null, + base: null, + parse: null, + comment: false, + format: { + indent: { + style: " ", + base: 0, + adjustMultilineComment: false + }, + newline: "\n", + space: " ", + json: false, + renumber: false, + hexadecimal: false, + quotes: "single", + escapeless: false, + compact: false, + parentheses: true, + semicolons: true, + safeConcatenation: false, + preserveBlankLines: false + }, + moz: { + comprehensionExpressionStartsWithAssignment: false, + starlessGenerator: false + }, + sourceMap: null, + sourceMapRoot: null, + sourceMapWithCode: false, + directive: false, + raw: true, + verbatim: null, + sourceCode: null + }; + } + function stringRepeat(str, num) { + var result = ""; + for (num |= 0; num > 0; num >>>= 1, str += str) { + if (num & 1) { + result += str; + } + } + return result; + } + function hasLineTerminator(str) { + return /[\r\n]/g.test(str); + } + function endsWithLineTerminator(str) { + var len = str.length; + return len && esutils.code.isLineTerminator(str.charCodeAt(len - 1)); + } + function merge(target, override) { + var key; + for (key in override) { + if (override.hasOwnProperty(key)) { + target[key] = override[key]; + } + } + return target; + } + function updateDeeply(target, override) { + var key, val; + function isHashObject(target2) { + return typeof target2 === "object" && target2 instanceof Object && !(target2 instanceof RegExp); + } + for (key in override) { + if (override.hasOwnProperty(key)) { + val = override[key]; + if (isHashObject(val)) { + if (isHashObject(target[key])) { + updateDeeply(target[key], val); + } else { + target[key] = updateDeeply({}, val); + } + } else { + target[key] = val; + } + } + } + return target; + } + function generateNumber(value) { + var result, point, temp, exponent, pos; + if (value !== value) { + throw new Error("Numeric literal whose value is NaN"); + } + if (value < 0 || value === 0 && 1 / value < 0) { + throw new Error("Numeric literal whose value is negative"); + } + if (value === 1 / 0) { + return json ? "null" : renumber ? "1e400" : "1e+400"; + } + result = "" + value; + if (!renumber || result.length < 3) { + return result; + } + point = result.indexOf("."); + if (!json && result.charCodeAt(0) === 48 && point === 1) { + point = 0; + result = result.slice(1); + } + temp = result; + result = result.replace("e+", "e"); + exponent = 0; + if ((pos = temp.indexOf("e")) > 0) { + exponent = +temp.slice(pos + 1); + temp = temp.slice(0, pos); + } + if (point >= 0) { + exponent -= temp.length - point - 1; + temp = +(temp.slice(0, point) + temp.slice(point + 1)) + ""; + } + pos = 0; + while (temp.charCodeAt(temp.length + pos - 1) === 48) { + --pos; + } + if (pos !== 0) { + exponent -= pos; + temp = temp.slice(0, pos); + } + if (exponent !== 0) { + temp += "e" + exponent; + } + if ((temp.length < result.length || hexadecimal && value > 1e12 && Math.floor(value) === value && (temp = "0x" + value.toString(16)).length < result.length) && +temp === value) { + result = temp; + } + return result; + } + function escapeRegExpCharacter(ch, previousIsBackslash) { + if ((ch & ~1) === 8232) { + return (previousIsBackslash ? "u" : "\\u") + (ch === 8232 ? "2028" : "2029"); + } else if (ch === 10 || ch === 13) { + return (previousIsBackslash ? "" : "\\") + (ch === 10 ? "n" : "r"); + } + return String.fromCharCode(ch); + } + function generateRegExp(reg) { + var match, result, flags, i, iz, ch, characterInBrack, previousIsBackslash; + result = reg.toString(); + if (reg.source) { + match = result.match(/\/([^/]*)$/); + if (!match) { + return result; + } + flags = match[1]; + result = ""; + characterInBrack = false; + previousIsBackslash = false; + for (i = 0, iz = reg.source.length; i < iz; ++i) { + ch = reg.source.charCodeAt(i); + if (!previousIsBackslash) { + if (characterInBrack) { + if (ch === 93) { + characterInBrack = false; + } + } else { + if (ch === 47) { + result += "\\"; + } else if (ch === 91) { + characterInBrack = true; + } + } + result += escapeRegExpCharacter(ch, previousIsBackslash); + previousIsBackslash = ch === 92; + } else { + result += escapeRegExpCharacter(ch, previousIsBackslash); + previousIsBackslash = false; + } + } + return "/" + result + "/" + flags; + } + return result; + } + function escapeAllowedCharacter(code, next) { + var hex; + if (code === 8) { + return "\\b"; + } + if (code === 12) { + return "\\f"; + } + if (code === 9) { + return "\\t"; + } + hex = code.toString(16).toUpperCase(); + if (json || code > 255) { + return "\\u" + "0000".slice(hex.length) + hex; + } else if (code === 0 && !esutils.code.isDecimalDigit(next)) { + return "\\0"; + } else if (code === 11) { + return "\\x0B"; + } else { + return "\\x" + "00".slice(hex.length) + hex; + } + } + function escapeDisallowedCharacter(code) { + if (code === 92) { + return "\\\\"; + } + if (code === 10) { + return "\\n"; + } + if (code === 13) { + return "\\r"; + } + if (code === 8232) { + return "\\u2028"; + } + if (code === 8233) { + return "\\u2029"; + } + throw new Error("Incorrectly classified character"); + } + function escapeDirective(str) { + var i, iz, code, quote; + quote = quotes === "double" ? '"' : "'"; + for (i = 0, iz = str.length; i < iz; ++i) { + code = str.charCodeAt(i); + if (code === 39) { + quote = '"'; + break; + } else if (code === 34) { + quote = "'"; + break; + } else if (code === 92) { + ++i; + } + } + return quote + str + quote; + } + function escapeString(str) { + var result = "", i, len, code, singleQuotes = 0, doubleQuotes = 0, single, quote; + for (i = 0, len = str.length; i < len; ++i) { + code = str.charCodeAt(i); + if (code === 39) { + ++singleQuotes; + } else if (code === 34) { + ++doubleQuotes; + } else if (code === 47 && json) { + result += "\\"; + } else if (esutils.code.isLineTerminator(code) || code === 92) { + result += escapeDisallowedCharacter(code); + continue; + } else if (!esutils.code.isIdentifierPartES5(code) && (json && code < 32 || !json && !escapeless && (code < 32 || code > 126))) { + result += escapeAllowedCharacter(code, str.charCodeAt(i + 1)); + continue; + } + result += String.fromCharCode(code); + } + single = !(quotes === "double" || quotes === "auto" && doubleQuotes < singleQuotes); + quote = single ? "'" : '"'; + if (!(single ? singleQuotes : doubleQuotes)) { + return quote + result + quote; + } + str = result; + result = quote; + for (i = 0, len = str.length; i < len; ++i) { + code = str.charCodeAt(i); + if (code === 39 && single || code === 34 && !single) { + result += "\\"; + } + result += String.fromCharCode(code); + } + return result + quote; + } + function flattenToString(arr) { + var i, iz, elem, result = ""; + for (i = 0, iz = arr.length; i < iz; ++i) { + elem = arr[i]; + result += Array.isArray(elem) ? flattenToString(elem) : elem; + } + return result; + } + function toSourceNodeWhenNeeded(generated, node) { + if (!sourceMap) { + if (Array.isArray(generated)) { + return flattenToString(generated); + } else { + return generated; + } + } + if (node == null) { + if (generated instanceof SourceNode) { + return generated; + } else { + node = {}; + } + } + if (node.loc == null) { + return new SourceNode(null, null, sourceMap, generated, node.name || null); + } + return new SourceNode(node.loc.start.line, node.loc.start.column, sourceMap === true ? node.loc.source || null : sourceMap, generated, node.name || null); + } + function noEmptySpace() { + return space ? space : " "; + } + function join2(left2, right2) { + var leftSource, rightSource, leftCharCode, rightCharCode; + leftSource = toSourceNodeWhenNeeded(left2).toString(); + if (leftSource.length === 0) { + return [right2]; + } + rightSource = toSourceNodeWhenNeeded(right2).toString(); + if (rightSource.length === 0) { + return [left2]; + } + leftCharCode = leftSource.charCodeAt(leftSource.length - 1); + rightCharCode = rightSource.charCodeAt(0); + if ((leftCharCode === 43 || leftCharCode === 45) && leftCharCode === rightCharCode || esutils.code.isIdentifierPartES5(leftCharCode) && esutils.code.isIdentifierPartES5(rightCharCode) || leftCharCode === 47 && rightCharCode === 105) { + return [left2, noEmptySpace(), right2]; + } else if (esutils.code.isWhiteSpace(leftCharCode) || esutils.code.isLineTerminator(leftCharCode) || esutils.code.isWhiteSpace(rightCharCode) || esutils.code.isLineTerminator(rightCharCode)) { + return [left2, right2]; + } + return [left2, space, right2]; + } + function addIndent(stmt) { + return [base, stmt]; + } + function withIndent(fn) { + var previousBase; + previousBase = base; + base += indent; + fn(base); + base = previousBase; + } + function calculateSpaces(str) { + var i; + for (i = str.length - 1; i >= 0; --i) { + if (esutils.code.isLineTerminator(str.charCodeAt(i))) { + break; + } + } + return str.length - 1 - i; + } + function adjustMultilineComment(value, specialBase) { + var array, i, len, line, j, spaces, previousBase, sn; + array = value.split(/\r\n|[\r\n]/); + spaces = Number.MAX_VALUE; + for (i = 1, len = array.length; i < len; ++i) { + line = array[i]; + j = 0; + while (j < line.length && esutils.code.isWhiteSpace(line.charCodeAt(j))) { + ++j; + } + if (spaces > j) { + spaces = j; + } + } + if (typeof specialBase !== "undefined") { + previousBase = base; + if (array[1][spaces] === "*") { + specialBase += " "; + } + base = specialBase; + } else { + if (spaces & 1) { + --spaces; + } + previousBase = base; + } + for (i = 1, len = array.length; i < len; ++i) { + sn = toSourceNodeWhenNeeded(addIndent(array[i].slice(spaces))); + array[i] = sourceMap ? sn.join("") : sn; + } + base = previousBase; + return array.join("\n"); + } + function generateComment(comment, specialBase) { + if (comment.type === "Line") { + if (endsWithLineTerminator(comment.value)) { + return "//" + comment.value; + } else { + var result = "//" + comment.value; + if (!preserveBlankLines) { + result += "\n"; + } + return result; + } + } + if (extra.format.indent.adjustMultilineComment && /[\n\r]/.test(comment.value)) { + return adjustMultilineComment("/*" + comment.value + "*/", specialBase); + } + return "/*" + comment.value + "*/"; + } + function addComments(stmt, result) { + var i, len, comment, save, tailingToStatement, specialBase, fragment, extRange, range, prevRange, prefix, infix, suffix, count; + if (stmt.leadingComments && stmt.leadingComments.length > 0) { + save = result; + if (preserveBlankLines) { + comment = stmt.leadingComments[0]; + result = []; + extRange = comment.extendedRange; + range = comment.range; + prefix = sourceCode.substring(extRange[0], range[0]); + count = (prefix.match(/\n/g) || []).length; + if (count > 0) { + result.push(stringRepeat("\n", count)); + result.push(addIndent(generateComment(comment))); + } else { + result.push(prefix); + result.push(generateComment(comment)); + } + prevRange = range; + for (i = 1, len = stmt.leadingComments.length; i < len; i++) { + comment = stmt.leadingComments[i]; + range = comment.range; + infix = sourceCode.substring(prevRange[1], range[0]); + count = (infix.match(/\n/g) || []).length; + result.push(stringRepeat("\n", count)); + result.push(addIndent(generateComment(comment))); + prevRange = range; + } + suffix = sourceCode.substring(range[1], extRange[1]); + count = (suffix.match(/\n/g) || []).length; + result.push(stringRepeat("\n", count)); + } else { + comment = stmt.leadingComments[0]; + result = []; + if (safeConcatenation && stmt.type === Syntax.Program && stmt.body.length === 0) { + result.push("\n"); + } + result.push(generateComment(comment)); + if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { + result.push("\n"); + } + for (i = 1, len = stmt.leadingComments.length; i < len; ++i) { + comment = stmt.leadingComments[i]; + fragment = [generateComment(comment)]; + if (!endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { + fragment.push("\n"); + } + result.push(addIndent(fragment)); + } + } + result.push(addIndent(save)); + } + if (stmt.trailingComments) { + if (preserveBlankLines) { + comment = stmt.trailingComments[0]; + extRange = comment.extendedRange; + range = comment.range; + prefix = sourceCode.substring(extRange[0], range[0]); + count = (prefix.match(/\n/g) || []).length; + if (count > 0) { + result.push(stringRepeat("\n", count)); + result.push(addIndent(generateComment(comment))); + } else { + result.push(prefix); + result.push(generateComment(comment)); + } + } else { + tailingToStatement = !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString()); + specialBase = stringRepeat(" ", calculateSpaces(toSourceNodeWhenNeeded([base, result, indent]).toString())); + for (i = 0, len = stmt.trailingComments.length; i < len; ++i) { + comment = stmt.trailingComments[i]; + if (tailingToStatement) { + if (i === 0) { + result = [result, indent]; + } else { + result = [result, specialBase]; + } + result.push(generateComment(comment, specialBase)); + } else { + result = [result, addIndent(generateComment(comment))]; + } + if (i !== len - 1 && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { + result = [result, "\n"]; + } + } + } + } + return result; + } + function generateBlankLines(start, end, result) { + var j, newlineCount = 0; + for (j = start; j < end; j++) { + if (sourceCode[j] === "\n") { + newlineCount++; + } + } + for (j = 1; j < newlineCount; j++) { + result.push(newline); + } + } + function parenthesize(text, current, should2) { + if (current < should2) { + return ["(", text, ")"]; + } + return text; + } + function generateVerbatimString(string) { + var i, iz, result; + result = string.split(/\r\n|\n/); + for (i = 1, iz = result.length; i < iz; i++) { + result[i] = newline + base + result[i]; + } + return result; + } + function generateVerbatim(expr, precedence) { + var verbatim, result, prec; + verbatim = expr[extra.verbatim]; + if (typeof verbatim === "string") { + result = parenthesize(generateVerbatimString(verbatim), Precedence.Sequence, precedence); + } else { + result = generateVerbatimString(verbatim.content); + prec = verbatim.precedence != null ? verbatim.precedence : Precedence.Sequence; + result = parenthesize(result, prec, precedence); + } + return toSourceNodeWhenNeeded(result, expr); + } + function CodeGenerator() { + } + CodeGenerator.prototype.maybeBlock = function(stmt, flags) { + var result, noLeadingComment, that = this; + noLeadingComment = !extra.comment || !stmt.leadingComments; + if (stmt.type === Syntax.BlockStatement && noLeadingComment) { + return [space, this.generateStatement(stmt, flags)]; + } + if (stmt.type === Syntax.EmptyStatement && noLeadingComment) { + return ";"; + } + withIndent(function() { + result = [ + newline, + addIndent(that.generateStatement(stmt, flags)) + ]; + }); + return result; + }; + CodeGenerator.prototype.maybeBlockSuffix = function(stmt, result) { + var ends = endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString()); + if (stmt.type === Syntax.BlockStatement && (!extra.comment || !stmt.leadingComments) && !ends) { + return [result, space]; + } + if (ends) { + return [result, base]; + } + return [result, newline, base]; + }; + function generateIdentifier(node) { + return toSourceNodeWhenNeeded(node.name, node); + } + function generateAsyncPrefix(node, spaceRequired) { + return node.async ? "async" + (spaceRequired ? noEmptySpace() : space) : ""; + } + function generateStarSuffix(node) { + var isGenerator = node.generator && !extra.moz.starlessGenerator; + return isGenerator ? "*" + space : ""; + } + function generateMethodPrefix(prop) { + var func = prop.value, prefix = ""; + if (func.async) { + prefix += generateAsyncPrefix(func, !prop.computed); + } + if (func.generator) { + prefix += generateStarSuffix(func) ? "*" : ""; + } + return prefix; + } + CodeGenerator.prototype.generatePattern = function(node, precedence, flags) { + if (node.type === Syntax.Identifier) { + return generateIdentifier(node); + } + return this.generateExpression(node, precedence, flags); + }; + CodeGenerator.prototype.generateFunctionParams = function(node) { + var i, iz, result, hasDefault; + hasDefault = false; + if (node.type === Syntax.ArrowFunctionExpression && !node.rest && (!node.defaults || node.defaults.length === 0) && node.params.length === 1 && node.params[0].type === Syntax.Identifier) { + result = [generateAsyncPrefix(node, true), generateIdentifier(node.params[0])]; + } else { + result = node.type === Syntax.ArrowFunctionExpression ? [generateAsyncPrefix(node, false)] : []; + result.push("("); + if (node.defaults) { + hasDefault = true; + } + for (i = 0, iz = node.params.length; i < iz; ++i) { + if (hasDefault && node.defaults[i]) { + result.push(this.generateAssignment(node.params[i], node.defaults[i], "=", Precedence.Assignment, E_TTT)); + } else { + result.push(this.generatePattern(node.params[i], Precedence.Assignment, E_TTT)); + } + if (i + 1 < iz) { + result.push("," + space); + } + } + if (node.rest) { + if (node.params.length) { + result.push("," + space); + } + result.push("..."); + result.push(generateIdentifier(node.rest)); + } + result.push(")"); + } + return result; + }; + CodeGenerator.prototype.generateFunctionBody = function(node) { + var result, expr; + result = this.generateFunctionParams(node); + if (node.type === Syntax.ArrowFunctionExpression) { + result.push(space); + result.push("=>"); + } + if (node.expression) { + result.push(space); + expr = this.generateExpression(node.body, Precedence.Assignment, E_TTT); + if (expr.toString().charAt(0) === "{") { + expr = ["(", expr, ")"]; + } + result.push(expr); + } else { + result.push(this.maybeBlock(node.body, S_TTFF)); + } + return result; + }; + CodeGenerator.prototype.generateIterationForStatement = function(operator, stmt, flags) { + var result = ["for" + (stmt.await ? noEmptySpace() + "await" : "") + space + "("], that = this; + withIndent(function() { + if (stmt.left.type === Syntax.VariableDeclaration) { + withIndent(function() { + result.push(stmt.left.kind + noEmptySpace()); + result.push(that.generateStatement(stmt.left.declarations[0], S_FFFF)); + }); + } else { + result.push(that.generateExpression(stmt.left, Precedence.Call, E_TTT)); + } + result = join2(result, operator); + result = [join2( + result, + that.generateExpression(stmt.right, Precedence.Assignment, E_TTT) + ), ")"]; + }); + result.push(this.maybeBlock(stmt.body, flags)); + return result; + }; + CodeGenerator.prototype.generatePropertyKey = function(expr, computed) { + var result = []; + if (computed) { + result.push("["); + } + result.push(this.generateExpression(expr, Precedence.Assignment, E_TTT)); + if (computed) { + result.push("]"); + } + return result; + }; + CodeGenerator.prototype.generateAssignment = function(left2, right2, operator, precedence, flags) { + if (Precedence.Assignment < precedence) { + flags |= F_ALLOW_IN; + } + return parenthesize( + [ + this.generateExpression(left2, Precedence.Call, flags), + space + operator + space, + this.generateExpression(right2, Precedence.Assignment, flags) + ], + Precedence.Assignment, + precedence + ); + }; + CodeGenerator.prototype.semicolon = function(flags) { + if (!semicolons && flags & F_SEMICOLON_OPT) { + return ""; + } + return ";"; + }; + CodeGenerator.Statement = { + BlockStatement: function(stmt, flags) { + var range, content, result = ["{", newline], that = this; + withIndent(function() { + if (stmt.body.length === 0 && preserveBlankLines) { + range = stmt.range; + if (range[1] - range[0] > 2) { + content = sourceCode.substring(range[0] + 1, range[1] - 1); + if (content[0] === "\n") { + result = ["{"]; + } + result.push(content); + } + } + var i, iz, fragment, bodyFlags; + bodyFlags = S_TFFF; + if (flags & F_FUNC_BODY) { + bodyFlags |= F_DIRECTIVE_CTX; + } + for (i = 0, iz = stmt.body.length; i < iz; ++i) { + if (preserveBlankLines) { + if (i === 0) { + if (stmt.body[0].leadingComments) { + range = stmt.body[0].leadingComments[0].extendedRange; + content = sourceCode.substring(range[0], range[1]); + if (content[0] === "\n") { + result = ["{"]; + } + } + if (!stmt.body[0].leadingComments) { + generateBlankLines(stmt.range[0], stmt.body[0].range[0], result); + } + } + if (i > 0) { + if (!stmt.body[i - 1].trailingComments && !stmt.body[i].leadingComments) { + generateBlankLines(stmt.body[i - 1].range[1], stmt.body[i].range[0], result); + } + } + } + if (i === iz - 1) { + bodyFlags |= F_SEMICOLON_OPT; + } + if (stmt.body[i].leadingComments && preserveBlankLines) { + fragment = that.generateStatement(stmt.body[i], bodyFlags); + } else { + fragment = addIndent(that.generateStatement(stmt.body[i], bodyFlags)); + } + result.push(fragment); + if (!endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { + if (preserveBlankLines && i < iz - 1) { + if (!stmt.body[i + 1].leadingComments) { + result.push(newline); + } + } else { + result.push(newline); + } + } + if (preserveBlankLines) { + if (i === iz - 1) { + if (!stmt.body[i].trailingComments) { + generateBlankLines(stmt.body[i].range[1], stmt.range[1], result); + } + } + } + } + }); + result.push(addIndent("}")); + return result; + }, + BreakStatement: function(stmt, flags) { + if (stmt.label) { + return "break " + stmt.label.name + this.semicolon(flags); + } + return "break" + this.semicolon(flags); + }, + ContinueStatement: function(stmt, flags) { + if (stmt.label) { + return "continue " + stmt.label.name + this.semicolon(flags); + } + return "continue" + this.semicolon(flags); + }, + ClassBody: function(stmt, flags) { + var result = ["{", newline], that = this; + withIndent(function(indent2) { + var i, iz; + for (i = 0, iz = stmt.body.length; i < iz; ++i) { + result.push(indent2); + result.push(that.generateExpression(stmt.body[i], Precedence.Sequence, E_TTT)); + if (i + 1 < iz) { + result.push(newline); + } + } + }); + if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { + result.push(newline); + } + result.push(base); + result.push("}"); + return result; + }, + ClassDeclaration: function(stmt, flags) { + var result, fragment; + result = ["class"]; + if (stmt.id) { + result = join2(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT)); + } + if (stmt.superClass) { + fragment = join2("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT)); + result = join2(result, fragment); + } + result.push(space); + result.push(this.generateStatement(stmt.body, S_TFFT)); + return result; + }, + DirectiveStatement: function(stmt, flags) { + if (extra.raw && stmt.raw) { + return stmt.raw + this.semicolon(flags); + } + return escapeDirective(stmt.directive) + this.semicolon(flags); + }, + DoWhileStatement: function(stmt, flags) { + var result = join2("do", this.maybeBlock(stmt.body, S_TFFF)); + result = this.maybeBlockSuffix(stmt.body, result); + return join2(result, [ + "while" + space + "(", + this.generateExpression(stmt.test, Precedence.Sequence, E_TTT), + ")" + this.semicolon(flags) + ]); + }, + CatchClause: function(stmt, flags) { + var result, that = this; + withIndent(function() { + var guard; + if (stmt.param) { + result = [ + "catch" + space + "(", + that.generateExpression(stmt.param, Precedence.Sequence, E_TTT), + ")" + ]; + if (stmt.guard) { + guard = that.generateExpression(stmt.guard, Precedence.Sequence, E_TTT); + result.splice(2, 0, " if ", guard); + } + } else { + result = ["catch"]; + } + }); + result.push(this.maybeBlock(stmt.body, S_TFFF)); + return result; + }, + DebuggerStatement: function(stmt, flags) { + return "debugger" + this.semicolon(flags); + }, + EmptyStatement: function(stmt, flags) { + return ";"; + }, + ExportDefaultDeclaration: function(stmt, flags) { + var result = ["export"], bodyFlags; + bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF; + result = join2(result, "default"); + if (isStatement(stmt.declaration)) { + result = join2(result, this.generateStatement(stmt.declaration, bodyFlags)); + } else { + result = join2(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags)); + } + return result; + }, + ExportNamedDeclaration: function(stmt, flags) { + var result = ["export"], bodyFlags, that = this; + bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF; + if (stmt.declaration) { + return join2(result, this.generateStatement(stmt.declaration, bodyFlags)); + } + if (stmt.specifiers) { + if (stmt.specifiers.length === 0) { + result = join2(result, "{" + space + "}"); + } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) { + result = join2(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT)); + } else { + result = join2(result, "{"); + withIndent(function(indent2) { + var i, iz; + result.push(newline); + for (i = 0, iz = stmt.specifiers.length; i < iz; ++i) { + result.push(indent2); + result.push(that.generateExpression(stmt.specifiers[i], Precedence.Sequence, E_TTT)); + if (i + 1 < iz) { + result.push("," + newline); + } + } + }); + if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { + result.push(newline); + } + result.push(base + "}"); + } + if (stmt.source) { + result = join2(result, [ + "from" + space, + // ModuleSpecifier + this.generateExpression(stmt.source, Precedence.Sequence, E_TTT), + this.semicolon(flags) + ]); + } else { + result.push(this.semicolon(flags)); + } + } + return result; + }, + ExportAllDeclaration: function(stmt, flags) { + return [ + "export" + space, + "*" + space, + "from" + space, + // ModuleSpecifier + this.generateExpression(stmt.source, Precedence.Sequence, E_TTT), + this.semicolon(flags) + ]; + }, + ExpressionStatement: function(stmt, flags) { + var result, fragment; + function isClassPrefixed(fragment2) { + var code; + if (fragment2.slice(0, 5) !== "class") { + return false; + } + code = fragment2.charCodeAt(5); + return code === 123 || esutils.code.isWhiteSpace(code) || esutils.code.isLineTerminator(code); + } + function isFunctionPrefixed(fragment2) { + var code; + if (fragment2.slice(0, 8) !== "function") { + return false; + } + code = fragment2.charCodeAt(8); + return code === 40 || esutils.code.isWhiteSpace(code) || code === 42 || esutils.code.isLineTerminator(code); + } + function isAsyncPrefixed(fragment2) { + var code, i, iz; + if (fragment2.slice(0, 5) !== "async") { + return false; + } + if (!esutils.code.isWhiteSpace(fragment2.charCodeAt(5))) { + return false; + } + for (i = 6, iz = fragment2.length; i < iz; ++i) { + if (!esutils.code.isWhiteSpace(fragment2.charCodeAt(i))) { + break; + } + } + if (i === iz) { + return false; + } + if (fragment2.slice(i, i + 8) !== "function") { + return false; + } + code = fragment2.charCodeAt(i + 8); + return code === 40 || esutils.code.isWhiteSpace(code) || code === 42 || esutils.code.isLineTerminator(code); + } + result = [this.generateExpression(stmt.expression, Precedence.Sequence, E_TTT)]; + fragment = toSourceNodeWhenNeeded(result).toString(); + if (fragment.charCodeAt(0) === 123 || // ObjectExpression + isClassPrefixed(fragment) || isFunctionPrefixed(fragment) || isAsyncPrefixed(fragment) || directive && flags & F_DIRECTIVE_CTX && stmt.expression.type === Syntax.Literal && typeof stmt.expression.value === "string") { + result = ["(", result, ")" + this.semicolon(flags)]; + } else { + result.push(this.semicolon(flags)); + } + return result; + }, + ImportDeclaration: function(stmt, flags) { + var result, cursor, that = this; + if (stmt.specifiers.length === 0) { + return [ + "import", + space, + // ModuleSpecifier + this.generateExpression(stmt.source, Precedence.Sequence, E_TTT), + this.semicolon(flags) + ]; + } + result = [ + "import" + ]; + cursor = 0; + if (stmt.specifiers[cursor].type === Syntax.ImportDefaultSpecifier) { + result = join2(result, [ + this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT) + ]); + ++cursor; + } + if (stmt.specifiers[cursor]) { + if (cursor !== 0) { + result.push(","); + } + if (stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier) { + result = join2(result, [ + space, + this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT) + ]); + } else { + result.push(space + "{"); + if (stmt.specifiers.length - cursor === 1) { + result.push(space); + result.push(this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)); + result.push(space + "}" + space); + } else { + withIndent(function(indent2) { + var i, iz; + result.push(newline); + for (i = cursor, iz = stmt.specifiers.length; i < iz; ++i) { + result.push(indent2); + result.push(that.generateExpression(stmt.specifiers[i], Precedence.Sequence, E_TTT)); + if (i + 1 < iz) { + result.push("," + newline); + } + } + }); + if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { + result.push(newline); + } + result.push(base + "}" + space); + } + } + } + result = join2(result, [ + "from" + space, + // ModuleSpecifier + this.generateExpression(stmt.source, Precedence.Sequence, E_TTT), + this.semicolon(flags) + ]); + return result; + }, + VariableDeclarator: function(stmt, flags) { + var itemFlags = flags & F_ALLOW_IN ? E_TTT : E_FTT; + if (stmt.init) { + return [ + this.generateExpression(stmt.id, Precedence.Assignment, itemFlags), + space, + "=", + space, + this.generateExpression(stmt.init, Precedence.Assignment, itemFlags) + ]; + } + return this.generatePattern(stmt.id, Precedence.Assignment, itemFlags); + }, + VariableDeclaration: function(stmt, flags) { + var result, i, iz, node, bodyFlags, that = this; + result = [stmt.kind]; + bodyFlags = flags & F_ALLOW_IN ? S_TFFF : S_FFFF; + function block() { + node = stmt.declarations[0]; + if (extra.comment && node.leadingComments) { + result.push("\n"); + result.push(addIndent(that.generateStatement(node, bodyFlags))); + } else { + result.push(noEmptySpace()); + result.push(that.generateStatement(node, bodyFlags)); + } + for (i = 1, iz = stmt.declarations.length; i < iz; ++i) { + node = stmt.declarations[i]; + if (extra.comment && node.leadingComments) { + result.push("," + newline); + result.push(addIndent(that.generateStatement(node, bodyFlags))); + } else { + result.push("," + space); + result.push(that.generateStatement(node, bodyFlags)); + } + } + } + if (stmt.declarations.length > 1) { + withIndent(block); + } else { + block(); + } + result.push(this.semicolon(flags)); + return result; + }, + ThrowStatement: function(stmt, flags) { + return [join2( + "throw", + this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT) + ), this.semicolon(flags)]; + }, + TryStatement: function(stmt, flags) { + var result, i, iz, guardedHandlers; + result = ["try", this.maybeBlock(stmt.block, S_TFFF)]; + result = this.maybeBlockSuffix(stmt.block, result); + if (stmt.handlers) { + for (i = 0, iz = stmt.handlers.length; i < iz; ++i) { + result = join2(result, this.generateStatement(stmt.handlers[i], S_TFFF)); + if (stmt.finalizer || i + 1 !== iz) { + result = this.maybeBlockSuffix(stmt.handlers[i].body, result); + } + } + } else { + guardedHandlers = stmt.guardedHandlers || []; + for (i = 0, iz = guardedHandlers.length; i < iz; ++i) { + result = join2(result, this.generateStatement(guardedHandlers[i], S_TFFF)); + if (stmt.finalizer || i + 1 !== iz) { + result = this.maybeBlockSuffix(guardedHandlers[i].body, result); + } + } + if (stmt.handler) { + if (Array.isArray(stmt.handler)) { + for (i = 0, iz = stmt.handler.length; i < iz; ++i) { + result = join2(result, this.generateStatement(stmt.handler[i], S_TFFF)); + if (stmt.finalizer || i + 1 !== iz) { + result = this.maybeBlockSuffix(stmt.handler[i].body, result); + } + } + } else { + result = join2(result, this.generateStatement(stmt.handler, S_TFFF)); + if (stmt.finalizer) { + result = this.maybeBlockSuffix(stmt.handler.body, result); + } + } + } + } + if (stmt.finalizer) { + result = join2(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]); + } + return result; + }, + SwitchStatement: function(stmt, flags) { + var result, fragment, i, iz, bodyFlags, that = this; + withIndent(function() { + result = [ + "switch" + space + "(", + that.generateExpression(stmt.discriminant, Precedence.Sequence, E_TTT), + ")" + space + "{" + newline + ]; + }); + if (stmt.cases) { + bodyFlags = S_TFFF; + for (i = 0, iz = stmt.cases.length; i < iz; ++i) { + if (i === iz - 1) { + bodyFlags |= F_SEMICOLON_OPT; + } + fragment = addIndent(this.generateStatement(stmt.cases[i], bodyFlags)); + result.push(fragment); + if (!endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { + result.push(newline); + } + } + } + result.push(addIndent("}")); + return result; + }, + SwitchCase: function(stmt, flags) { + var result, fragment, i, iz, bodyFlags, that = this; + withIndent(function() { + if (stmt.test) { + result = [ + join2("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)), + ":" + ]; + } else { + result = ["default:"]; + } + i = 0; + iz = stmt.consequent.length; + if (iz && stmt.consequent[0].type === Syntax.BlockStatement) { + fragment = that.maybeBlock(stmt.consequent[0], S_TFFF); + result.push(fragment); + i = 1; + } + if (i !== iz && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { + result.push(newline); + } + bodyFlags = S_TFFF; + for (; i < iz; ++i) { + if (i === iz - 1 && flags & F_SEMICOLON_OPT) { + bodyFlags |= F_SEMICOLON_OPT; + } + fragment = addIndent(that.generateStatement(stmt.consequent[i], bodyFlags)); + result.push(fragment); + if (i + 1 !== iz && !endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { + result.push(newline); + } + } + }); + return result; + }, + IfStatement: function(stmt, flags) { + var result, bodyFlags, semicolonOptional, that = this; + withIndent(function() { + result = [ + "if" + space + "(", + that.generateExpression(stmt.test, Precedence.Sequence, E_TTT), + ")" + ]; + }); + semicolonOptional = flags & F_SEMICOLON_OPT; + bodyFlags = S_TFFF; + if (semicolonOptional) { + bodyFlags |= F_SEMICOLON_OPT; + } + if (stmt.alternate) { + result.push(this.maybeBlock(stmt.consequent, S_TFFF)); + result = this.maybeBlockSuffix(stmt.consequent, result); + if (stmt.alternate.type === Syntax.IfStatement) { + result = join2(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]); + } else { + result = join2(result, join2("else", this.maybeBlock(stmt.alternate, bodyFlags))); + } + } else { + result.push(this.maybeBlock(stmt.consequent, bodyFlags)); + } + return result; + }, + ForStatement: function(stmt, flags) { + var result, that = this; + withIndent(function() { + result = ["for" + space + "("]; + if (stmt.init) { + if (stmt.init.type === Syntax.VariableDeclaration) { + result.push(that.generateStatement(stmt.init, S_FFFF)); + } else { + result.push(that.generateExpression(stmt.init, Precedence.Sequence, E_FTT)); + result.push(";"); + } + } else { + result.push(";"); + } + if (stmt.test) { + result.push(space); + result.push(that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)); + result.push(";"); + } else { + result.push(";"); + } + if (stmt.update) { + result.push(space); + result.push(that.generateExpression(stmt.update, Precedence.Sequence, E_TTT)); + result.push(")"); + } else { + result.push(")"); + } + }); + result.push(this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF)); + return result; + }, + ForInStatement: function(stmt, flags) { + return this.generateIterationForStatement("in", stmt, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF); + }, + ForOfStatement: function(stmt, flags) { + return this.generateIterationForStatement("of", stmt, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF); + }, + LabeledStatement: function(stmt, flags) { + return [stmt.label.name + ":", this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF)]; + }, + Program: function(stmt, flags) { + var result, fragment, i, iz, bodyFlags; + iz = stmt.body.length; + result = [safeConcatenation && iz > 0 ? "\n" : ""]; + bodyFlags = S_TFTF; + for (i = 0; i < iz; ++i) { + if (!safeConcatenation && i === iz - 1) { + bodyFlags |= F_SEMICOLON_OPT; + } + if (preserveBlankLines) { + if (i === 0) { + if (!stmt.body[0].leadingComments) { + generateBlankLines(stmt.range[0], stmt.body[i].range[0], result); + } + } + if (i > 0) { + if (!stmt.body[i - 1].trailingComments && !stmt.body[i].leadingComments) { + generateBlankLines(stmt.body[i - 1].range[1], stmt.body[i].range[0], result); + } + } + } + fragment = addIndent(this.generateStatement(stmt.body[i], bodyFlags)); + result.push(fragment); + if (i + 1 < iz && !endsWithLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { + if (preserveBlankLines) { + if (!stmt.body[i + 1].leadingComments) { + result.push(newline); + } + } else { + result.push(newline); + } + } + if (preserveBlankLines) { + if (i === iz - 1) { + if (!stmt.body[i].trailingComments) { + generateBlankLines(stmt.body[i].range[1], stmt.range[1], result); + } + } + } + } + return result; + }, + FunctionDeclaration: function(stmt, flags) { + return [ + generateAsyncPrefix(stmt, true), + "function", + generateStarSuffix(stmt) || noEmptySpace(), + stmt.id ? generateIdentifier(stmt.id) : "", + this.generateFunctionBody(stmt) + ]; + }, + ReturnStatement: function(stmt, flags) { + if (stmt.argument) { + return [join2( + "return", + this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT) + ), this.semicolon(flags)]; + } + return ["return" + this.semicolon(flags)]; + }, + WhileStatement: function(stmt, flags) { + var result, that = this; + withIndent(function() { + result = [ + "while" + space + "(", + that.generateExpression(stmt.test, Precedence.Sequence, E_TTT), + ")" + ]; + }); + result.push(this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF)); + return result; + }, + WithStatement: function(stmt, flags) { + var result, that = this; + withIndent(function() { + result = [ + "with" + space + "(", + that.generateExpression(stmt.object, Precedence.Sequence, E_TTT), + ")" + ]; + }); + result.push(this.maybeBlock(stmt.body, flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF)); + return result; + } + }; + merge(CodeGenerator.prototype, CodeGenerator.Statement); + CodeGenerator.Expression = { + SequenceExpression: function(expr, precedence, flags) { + var result, i, iz; + if (Precedence.Sequence < precedence) { + flags |= F_ALLOW_IN; + } + result = []; + for (i = 0, iz = expr.expressions.length; i < iz; ++i) { + result.push(this.generateExpression(expr.expressions[i], Precedence.Assignment, flags)); + if (i + 1 < iz) { + result.push("," + space); + } + } + return parenthesize(result, Precedence.Sequence, precedence); + }, + AssignmentExpression: function(expr, precedence, flags) { + return this.generateAssignment(expr.left, expr.right, expr.operator, precedence, flags); + }, + ArrowFunctionExpression: function(expr, precedence, flags) { + return parenthesize(this.generateFunctionBody(expr), Precedence.ArrowFunction, precedence); + }, + ConditionalExpression: function(expr, precedence, flags) { + if (Precedence.Conditional < precedence) { + flags |= F_ALLOW_IN; + } + return parenthesize( + [ + this.generateExpression(expr.test, Precedence.Coalesce, flags), + space + "?" + space, + this.generateExpression(expr.consequent, Precedence.Assignment, flags), + space + ":" + space, + this.generateExpression(expr.alternate, Precedence.Assignment, flags) + ], + Precedence.Conditional, + precedence + ); + }, + LogicalExpression: function(expr, precedence, flags) { + if (expr.operator === "??") { + flags |= F_FOUND_COALESCE; + } + return this.BinaryExpression(expr, precedence, flags); + }, + BinaryExpression: function(expr, precedence, flags) { + var result, leftPrecedence, rightPrecedence, currentPrecedence, fragment, leftSource; + currentPrecedence = BinaryPrecedence[expr.operator]; + leftPrecedence = expr.operator === "**" ? Precedence.Postfix : currentPrecedence; + rightPrecedence = expr.operator === "**" ? currentPrecedence : currentPrecedence + 1; + if (currentPrecedence < precedence) { + flags |= F_ALLOW_IN; + } + fragment = this.generateExpression(expr.left, leftPrecedence, flags); + leftSource = fragment.toString(); + if (leftSource.charCodeAt(leftSource.length - 1) === 47 && esutils.code.isIdentifierPartES5(expr.operator.charCodeAt(0))) { + result = [fragment, noEmptySpace(), expr.operator]; + } else { + result = join2(fragment, expr.operator); + } + fragment = this.generateExpression(expr.right, rightPrecedence, flags); + if (expr.operator === "/" && fragment.toString().charAt(0) === "/" || expr.operator.slice(-1) === "<" && fragment.toString().slice(0, 3) === "!--") { + result.push(noEmptySpace()); + result.push(fragment); + } else { + result = join2(result, fragment); + } + if (expr.operator === "in" && !(flags & F_ALLOW_IN)) { + return ["(", result, ")"]; + } + if ((expr.operator === "||" || expr.operator === "&&") && flags & F_FOUND_COALESCE) { + return ["(", result, ")"]; + } + return parenthesize(result, currentPrecedence, precedence); + }, + CallExpression: function(expr, precedence, flags) { + var result, i, iz; + result = [this.generateExpression(expr.callee, Precedence.Call, E_TTF)]; + if (expr.optional) { + result.push("?."); + } + result.push("("); + for (i = 0, iz = expr["arguments"].length; i < iz; ++i) { + result.push(this.generateExpression(expr["arguments"][i], Precedence.Assignment, E_TTT)); + if (i + 1 < iz) { + result.push("," + space); + } + } + result.push(")"); + if (!(flags & F_ALLOW_CALL)) { + return ["(", result, ")"]; + } + return parenthesize(result, Precedence.Call, precedence); + }, + ChainExpression: function(expr, precedence, flags) { + if (Precedence.OptionalChaining < precedence) { + flags |= F_ALLOW_CALL; + } + var result = this.generateExpression(expr.expression, Precedence.OptionalChaining, flags); + return parenthesize(result, Precedence.OptionalChaining, precedence); + }, + NewExpression: function(expr, precedence, flags) { + var result, length, i, iz, itemFlags; + length = expr["arguments"].length; + itemFlags = flags & F_ALLOW_UNPARATH_NEW && !parentheses && length === 0 ? E_TFT : E_TFF; + result = join2( + "new", + this.generateExpression(expr.callee, Precedence.New, itemFlags) + ); + if (!(flags & F_ALLOW_UNPARATH_NEW) || parentheses || length > 0) { + result.push("("); + for (i = 0, iz = length; i < iz; ++i) { + result.push(this.generateExpression(expr["arguments"][i], Precedence.Assignment, E_TTT)); + if (i + 1 < iz) { + result.push("," + space); + } + } + result.push(")"); + } + return parenthesize(result, Precedence.New, precedence); + }, + MemberExpression: function(expr, precedence, flags) { + var result, fragment; + result = [this.generateExpression(expr.object, Precedence.Call, flags & F_ALLOW_CALL ? E_TTF : E_TFF)]; + if (expr.computed) { + if (expr.optional) { + result.push("?."); + } + result.push("["); + result.push(this.generateExpression(expr.property, Precedence.Sequence, flags & F_ALLOW_CALL ? E_TTT : E_TFT)); + result.push("]"); + } else { + if (!expr.optional && expr.object.type === Syntax.Literal && typeof expr.object.value === "number") { + fragment = toSourceNodeWhenNeeded(result).toString(); + if (fragment.indexOf(".") < 0 && !/[eExX]/.test(fragment) && esutils.code.isDecimalDigit(fragment.charCodeAt(fragment.length - 1)) && !(fragment.length >= 2 && fragment.charCodeAt(0) === 48)) { + result.push(" "); + } + } + result.push(expr.optional ? "?." : "."); + result.push(generateIdentifier(expr.property)); + } + return parenthesize(result, Precedence.Member, precedence); + }, + MetaProperty: function(expr, precedence, flags) { + var result; + result = []; + result.push(typeof expr.meta === "string" ? expr.meta : generateIdentifier(expr.meta)); + result.push("."); + result.push(typeof expr.property === "string" ? expr.property : generateIdentifier(expr.property)); + return parenthesize(result, Precedence.Member, precedence); + }, + UnaryExpression: function(expr, precedence, flags) { + var result, fragment, rightCharCode, leftSource, leftCharCode; + fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT); + if (space === "") { + result = join2(expr.operator, fragment); + } else { + result = [expr.operator]; + if (expr.operator.length > 2) { + result = join2(result, fragment); + } else { + leftSource = toSourceNodeWhenNeeded(result).toString(); + leftCharCode = leftSource.charCodeAt(leftSource.length - 1); + rightCharCode = fragment.toString().charCodeAt(0); + if ((leftCharCode === 43 || leftCharCode === 45) && leftCharCode === rightCharCode || esutils.code.isIdentifierPartES5(leftCharCode) && esutils.code.isIdentifierPartES5(rightCharCode)) { + result.push(noEmptySpace()); + result.push(fragment); + } else { + result.push(fragment); + } + } + } + return parenthesize(result, Precedence.Unary, precedence); + }, + YieldExpression: function(expr, precedence, flags) { + var result; + if (expr.delegate) { + result = "yield*"; + } else { + result = "yield"; + } + if (expr.argument) { + result = join2( + result, + this.generateExpression(expr.argument, Precedence.Yield, E_TTT) + ); + } + return parenthesize(result, Precedence.Yield, precedence); + }, + AwaitExpression: function(expr, precedence, flags) { + var result = join2( + expr.all ? "await*" : "await", + this.generateExpression(expr.argument, Precedence.Await, E_TTT) + ); + return parenthesize(result, Precedence.Await, precedence); + }, + UpdateExpression: function(expr, precedence, flags) { + if (expr.prefix) { + return parenthesize( + [ + expr.operator, + this.generateExpression(expr.argument, Precedence.Unary, E_TTT) + ], + Precedence.Unary, + precedence + ); + } + return parenthesize( + [ + this.generateExpression(expr.argument, Precedence.Postfix, E_TTT), + expr.operator + ], + Precedence.Postfix, + precedence + ); + }, + FunctionExpression: function(expr, precedence, flags) { + var result = [ + generateAsyncPrefix(expr, true), + "function" + ]; + if (expr.id) { + result.push(generateStarSuffix(expr) || noEmptySpace()); + result.push(generateIdentifier(expr.id)); + } else { + result.push(generateStarSuffix(expr) || space); + } + result.push(this.generateFunctionBody(expr)); + return result; + }, + ArrayPattern: function(expr, precedence, flags) { + return this.ArrayExpression(expr, precedence, flags, true); + }, + ArrayExpression: function(expr, precedence, flags, isPattern) { + var result, multiline, that = this; + if (!expr.elements.length) { + return "[]"; + } + multiline = isPattern ? false : expr.elements.length > 1; + result = ["[", multiline ? newline : ""]; + withIndent(function(indent2) { + var i, iz; + for (i = 0, iz = expr.elements.length; i < iz; ++i) { + if (!expr.elements[i]) { + if (multiline) { + result.push(indent2); + } + if (i + 1 === iz) { + result.push(","); + } + } else { + result.push(multiline ? indent2 : ""); + result.push(that.generateExpression(expr.elements[i], Precedence.Assignment, E_TTT)); + } + if (i + 1 < iz) { + result.push("," + (multiline ? newline : space)); + } + } + }); + if (multiline && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { + result.push(newline); + } + result.push(multiline ? base : ""); + result.push("]"); + return result; + }, + RestElement: function(expr, precedence, flags) { + return "..." + this.generatePattern(expr.argument); + }, + ClassExpression: function(expr, precedence, flags) { + var result, fragment; + result = ["class"]; + if (expr.id) { + result = join2(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT)); + } + if (expr.superClass) { + fragment = join2("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT)); + result = join2(result, fragment); + } + result.push(space); + result.push(this.generateStatement(expr.body, S_TFFT)); + return result; + }, + MethodDefinition: function(expr, precedence, flags) { + var result, fragment; + if (expr["static"]) { + result = ["static" + space]; + } else { + result = []; + } + if (expr.kind === "get" || expr.kind === "set") { + fragment = [ + join2(expr.kind, this.generatePropertyKey(expr.key, expr.computed)), + this.generateFunctionBody(expr.value) + ]; + } else { + fragment = [ + generateMethodPrefix(expr), + this.generatePropertyKey(expr.key, expr.computed), + this.generateFunctionBody(expr.value) + ]; + } + return join2(result, fragment); + }, + Property: function(expr, precedence, flags) { + if (expr.kind === "get" || expr.kind === "set") { + return [ + expr.kind, + noEmptySpace(), + this.generatePropertyKey(expr.key, expr.computed), + this.generateFunctionBody(expr.value) + ]; + } + if (expr.shorthand) { + if (expr.value.type === "AssignmentPattern") { + return this.AssignmentPattern(expr.value, Precedence.Sequence, E_TTT); + } + return this.generatePropertyKey(expr.key, expr.computed); + } + if (expr.method) { + return [ + generateMethodPrefix(expr), + this.generatePropertyKey(expr.key, expr.computed), + this.generateFunctionBody(expr.value) + ]; + } + return [ + this.generatePropertyKey(expr.key, expr.computed), + ":" + space, + this.generateExpression(expr.value, Precedence.Assignment, E_TTT) + ]; + }, + ObjectExpression: function(expr, precedence, flags) { + var multiline, result, fragment, that = this; + if (!expr.properties.length) { + return "{}"; + } + multiline = expr.properties.length > 1; + withIndent(function() { + fragment = that.generateExpression(expr.properties[0], Precedence.Sequence, E_TTT); + }); + if (!multiline) { + if (!hasLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) { + return ["{", space, fragment, space, "}"]; + } + } + withIndent(function(indent2) { + var i, iz; + result = ["{", newline, indent2, fragment]; + if (multiline) { + result.push("," + newline); + for (i = 1, iz = expr.properties.length; i < iz; ++i) { + result.push(indent2); + result.push(that.generateExpression(expr.properties[i], Precedence.Sequence, E_TTT)); + if (i + 1 < iz) { + result.push("," + newline); + } + } + } + }); + if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { + result.push(newline); + } + result.push(base); + result.push("}"); + return result; + }, + AssignmentPattern: function(expr, precedence, flags) { + return this.generateAssignment(expr.left, expr.right, "=", precedence, flags); + }, + ObjectPattern: function(expr, precedence, flags) { + var result, i, iz, multiline, property, that = this; + if (!expr.properties.length) { + return "{}"; + } + multiline = false; + if (expr.properties.length === 1) { + property = expr.properties[0]; + if (property.type === Syntax.Property && property.value.type !== Syntax.Identifier) { + multiline = true; + } + } else { + for (i = 0, iz = expr.properties.length; i < iz; ++i) { + property = expr.properties[i]; + if (property.type === Syntax.Property && !property.shorthand) { + multiline = true; + break; + } + } + } + result = ["{", multiline ? newline : ""]; + withIndent(function(indent2) { + var i2, iz2; + for (i2 = 0, iz2 = expr.properties.length; i2 < iz2; ++i2) { + result.push(multiline ? indent2 : ""); + result.push(that.generateExpression(expr.properties[i2], Precedence.Sequence, E_TTT)); + if (i2 + 1 < iz2) { + result.push("," + (multiline ? newline : space)); + } + } + }); + if (multiline && !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) { + result.push(newline); + } + result.push(multiline ? base : ""); + result.push("}"); + return result; + }, + ThisExpression: function(expr, precedence, flags) { + return "this"; + }, + Super: function(expr, precedence, flags) { + return "super"; + }, + Identifier: function(expr, precedence, flags) { + return generateIdentifier(expr); + }, + ImportDefaultSpecifier: function(expr, precedence, flags) { + return generateIdentifier(expr.id || expr.local); + }, + ImportNamespaceSpecifier: function(expr, precedence, flags) { + var result = ["*"]; + var id = expr.id || expr.local; + if (id) { + result.push(space + "as" + noEmptySpace() + generateIdentifier(id)); + } + return result; + }, + ImportSpecifier: function(expr, precedence, flags) { + var imported = expr.imported; + var result = [imported.name]; + var local = expr.local; + if (local && local.name !== imported.name) { + result.push(noEmptySpace() + "as" + noEmptySpace() + generateIdentifier(local)); + } + return result; + }, + ExportSpecifier: function(expr, precedence, flags) { + var local = expr.local; + var result = [local.name]; + var exported = expr.exported; + if (exported && exported.name !== local.name) { + result.push(noEmptySpace() + "as" + noEmptySpace() + generateIdentifier(exported)); + } + return result; + }, + Literal: function(expr, precedence, flags) { + var raw; + if (expr.hasOwnProperty("raw") && parse && extra.raw) { + try { + raw = parse(expr.raw).body[0].expression; + if (raw.type === Syntax.Literal) { + if (raw.value === expr.value) { + return expr.raw; + } + } + } catch (e) { + } + } + if (expr.regex) { + return "/" + expr.regex.pattern + "/" + expr.regex.flags; + } + if (typeof expr.value === "bigint") { + return expr.value.toString() + "n"; + } + if (expr.bigint) { + return expr.bigint + "n"; + } + if (expr.value === null) { + return "null"; + } + if (typeof expr.value === "string") { + return escapeString(expr.value); + } + if (typeof expr.value === "number") { + return generateNumber(expr.value); + } + if (typeof expr.value === "boolean") { + return expr.value ? "true" : "false"; + } + return generateRegExp(expr.value); + }, + GeneratorExpression: function(expr, precedence, flags) { + return this.ComprehensionExpression(expr, precedence, flags); + }, + ComprehensionExpression: function(expr, precedence, flags) { + var result, i, iz, fragment, that = this; + result = expr.type === Syntax.GeneratorExpression ? ["("] : ["["]; + if (extra.moz.comprehensionExpressionStartsWithAssignment) { + fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT); + result.push(fragment); + } + if (expr.blocks) { + withIndent(function() { + for (i = 0, iz = expr.blocks.length; i < iz; ++i) { + fragment = that.generateExpression(expr.blocks[i], Precedence.Sequence, E_TTT); + if (i > 0 || extra.moz.comprehensionExpressionStartsWithAssignment) { + result = join2(result, fragment); + } else { + result.push(fragment); + } + } + }); + } + if (expr.filter) { + result = join2(result, "if" + space); + fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT); + result = join2(result, ["(", fragment, ")"]); + } + if (!extra.moz.comprehensionExpressionStartsWithAssignment) { + fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT); + result = join2(result, fragment); + } + result.push(expr.type === Syntax.GeneratorExpression ? ")" : "]"); + return result; + }, + ComprehensionBlock: function(expr, precedence, flags) { + var fragment; + if (expr.left.type === Syntax.VariableDeclaration) { + fragment = [ + expr.left.kind, + noEmptySpace(), + this.generateStatement(expr.left.declarations[0], S_FFFF) + ]; + } else { + fragment = this.generateExpression(expr.left, Precedence.Call, E_TTT); + } + fragment = join2(fragment, expr.of ? "of" : "in"); + fragment = join2(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT)); + return ["for" + space + "(", fragment, ")"]; + }, + SpreadElement: function(expr, precedence, flags) { + return [ + "...", + this.generateExpression(expr.argument, Precedence.Assignment, E_TTT) + ]; + }, + TaggedTemplateExpression: function(expr, precedence, flags) { + var itemFlags = E_TTF; + if (!(flags & F_ALLOW_CALL)) { + itemFlags = E_TFF; + } + var result = [ + this.generateExpression(expr.tag, Precedence.Call, itemFlags), + this.generateExpression(expr.quasi, Precedence.Primary, E_FFT) + ]; + return parenthesize(result, Precedence.TaggedTemplate, precedence); + }, + TemplateElement: function(expr, precedence, flags) { + return expr.value.raw; + }, + TemplateLiteral: function(expr, precedence, flags) { + var result, i, iz; + result = ["`"]; + for (i = 0, iz = expr.quasis.length; i < iz; ++i) { + result.push(this.generateExpression(expr.quasis[i], Precedence.Primary, E_TTT)); + if (i + 1 < iz) { + result.push("${" + space); + result.push(this.generateExpression(expr.expressions[i], Precedence.Sequence, E_TTT)); + result.push(space + "}"); + } + } + result.push("`"); + return result; + }, + ModuleSpecifier: function(expr, precedence, flags) { + return this.Literal(expr, precedence, flags); + }, + ImportExpression: function(expr, precedence, flag) { + return parenthesize([ + "import(", + this.generateExpression(expr.source, Precedence.Assignment, E_TTT), + ")" + ], Precedence.Call, precedence); + } + }; + merge(CodeGenerator.prototype, CodeGenerator.Expression); + CodeGenerator.prototype.generateExpression = function(expr, precedence, flags) { + var result, type; + type = expr.type || Syntax.Property; + if (extra.verbatim && expr.hasOwnProperty(extra.verbatim)) { + return generateVerbatim(expr, precedence); + } + result = this[type](expr, precedence, flags); + if (extra.comment) { + result = addComments(expr, result); + } + return toSourceNodeWhenNeeded(result, expr); + }; + CodeGenerator.prototype.generateStatement = function(stmt, flags) { + var result, fragment; + result = this[stmt.type](stmt, flags); + if (extra.comment) { + result = addComments(stmt, result); + } + fragment = toSourceNodeWhenNeeded(result).toString(); + if (stmt.type === Syntax.Program && !safeConcatenation && newline === "" && fragment.charAt(fragment.length - 1) === "\n") { + result = sourceMap ? toSourceNodeWhenNeeded(result).replaceRight(/\s+$/, "") : fragment.replace(/\s+$/, ""); + } + return toSourceNodeWhenNeeded(result, stmt); + }; + function generateInternal(node) { + var codegen; + codegen = new CodeGenerator(); + if (isStatement(node)) { + return codegen.generateStatement(node, S_TFFF); + } + if (isExpression(node)) { + return codegen.generateExpression(node, Precedence.Sequence, E_TTT); + } + throw new Error("Unknown node type: " + node.type); + } + function generate(node, options) { + var defaultOptions = getDefaultOptions(), result, pair; + if (options != null) { + if (typeof options.indent === "string") { + defaultOptions.format.indent.style = options.indent; + } + if (typeof options.base === "number") { + defaultOptions.format.indent.base = options.base; + } + options = updateDeeply(defaultOptions, options); + indent = options.format.indent.style; + if (typeof options.base === "string") { + base = options.base; + } else { + base = stringRepeat(indent, options.format.indent.base); + } + } else { + options = defaultOptions; + indent = options.format.indent.style; + base = stringRepeat(indent, options.format.indent.base); + } + json = options.format.json; + renumber = options.format.renumber; + hexadecimal = json ? false : options.format.hexadecimal; + quotes = json ? "double" : options.format.quotes; + escapeless = options.format.escapeless; + newline = options.format.newline; + space = options.format.space; + if (options.format.compact) { + newline = space = indent = base = ""; + } + parentheses = options.format.parentheses; + semicolons = options.format.semicolons; + safeConcatenation = options.format.safeConcatenation; + directive = options.directive; + parse = json ? null : options.parse; + sourceMap = options.sourceMap; + sourceCode = options.sourceCode; + preserveBlankLines = options.format.preserveBlankLines && sourceCode !== null; + extra = options; + if (sourceMap) { + if (!exports.browser) { + SourceNode = require_source_map().SourceNode; + } else { + SourceNode = global.sourceMap.SourceNode; + } + } + result = generateInternal(node); + if (!sourceMap) { + pair = { code: result.toString(), map: null }; + return options.sourceMapWithCode ? pair : pair.code; + } + pair = result.toStringWithSourceMap({ + file: options.file, + sourceRoot: options.sourceMapRoot + }); + if (options.sourceContent) { + pair.map.setSourceContent( + options.sourceMap, + options.sourceContent + ); + } + if (options.sourceMapWithCode) { + return pair; + } + return pair.map.toString(); + } + FORMAT_MINIFY = { + indent: { + style: "", + base: 0 + }, + renumber: true, + hexadecimal: true, + quotes: "auto", + escapeless: true, + compact: true, + parentheses: false, + semicolons: false + }; + FORMAT_DEFAULTS = getDefaultOptions().format; + exports.version = require_package().version; + exports.generate = generate; + exports.attachComments = estraverse.attachComments; + exports.Precedence = updateDeeply({}, Precedence); + exports.browser = false; + exports.FORMAT_MINIFY = FORMAT_MINIFY; + exports.FORMAT_DEFAULTS = FORMAT_DEFAULTS; + })(); + } +}); + +// ../testeranto/node_modules/esprima/dist/esprima.js +var require_esprima = __commonJS({ + "../testeranto/node_modules/esprima/dist/esprima.js"(exports, module) { + init_cjs_shim(); + (function webpackUniversalModuleDefinition(root, factory) { + if (typeof exports === "object" && typeof module === "object") + module.exports = factory(); + else if (typeof define === "function" && define.amd) + define([], factory); + else if (typeof exports === "object") + exports["esprima"] = factory(); + else + root["esprima"] = factory(); + })(exports, function() { + return ( + /******/ + function(modules) { + var installedModules = {}; + function __webpack_require__(moduleId) { + if (installedModules[moduleId]) + return installedModules[moduleId].exports; + var module2 = installedModules[moduleId] = { + /******/ + exports: {}, + /******/ + id: moduleId, + /******/ + loaded: false + /******/ + }; + modules[moduleId].call(module2.exports, module2, module2.exports, __webpack_require__); + module2.loaded = true; + return module2.exports; + } + __webpack_require__.m = modules; + __webpack_require__.c = installedModules; + __webpack_require__.p = ""; + return __webpack_require__(0); + }([ + /* 0 */ + /***/ + function(module2, exports2, __webpack_require__) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var comment_handler_1 = __webpack_require__(1); + var jsx_parser_1 = __webpack_require__(3); + var parser_1 = __webpack_require__(8); + var tokenizer_1 = __webpack_require__(15); + function parse(code, options, delegate) { + var commentHandler = null; + var proxyDelegate = function(node, metadata) { + if (delegate) { + delegate(node, metadata); + } + if (commentHandler) { + commentHandler.visit(node, metadata); + } + }; + var parserDelegate = typeof delegate === "function" ? proxyDelegate : null; + var collectComment = false; + if (options) { + collectComment = typeof options.comment === "boolean" && options.comment; + var attachComment = typeof options.attachComment === "boolean" && options.attachComment; + if (collectComment || attachComment) { + commentHandler = new comment_handler_1.CommentHandler(); + commentHandler.attach = attachComment; + options.comment = true; + parserDelegate = proxyDelegate; + } + } + var isModule = false; + if (options && typeof options.sourceType === "string") { + isModule = options.sourceType === "module"; + } + var parser2; + if (options && typeof options.jsx === "boolean" && options.jsx) { + parser2 = new jsx_parser_1.JSXParser(code, options, parserDelegate); + } else { + parser2 = new parser_1.Parser(code, options, parserDelegate); + } + var program = isModule ? parser2.parseModule() : parser2.parseScript(); + var ast = program; + if (collectComment && commentHandler) { + ast.comments = commentHandler.comments; + } + if (parser2.config.tokens) { + ast.tokens = parser2.tokens; + } + if (parser2.config.tolerant) { + ast.errors = parser2.errorHandler.errors; + } + return ast; + } + exports2.parse = parse; + function parseModule(code, options, delegate) { + var parsingOptions = options || {}; + parsingOptions.sourceType = "module"; + return parse(code, parsingOptions, delegate); + } + exports2.parseModule = parseModule; + function parseScript(code, options, delegate) { + var parsingOptions = options || {}; + parsingOptions.sourceType = "script"; + return parse(code, parsingOptions, delegate); + } + exports2.parseScript = parseScript; + function tokenize(code, options, delegate) { + var tokenizer = new tokenizer_1.Tokenizer(code, options); + var tokens; + tokens = []; + try { + while (true) { + var token = tokenizer.getNextToken(); + if (!token) { + break; + } + if (delegate) { + token = delegate(token); + } + tokens.push(token); + } + } catch (e) { + tokenizer.errorHandler.tolerate(e); + } + if (tokenizer.errorHandler.tolerant) { + tokens.errors = tokenizer.errors(); + } + return tokens; + } + exports2.tokenize = tokenize; + var syntax_1 = __webpack_require__(2); + exports2.Syntax = syntax_1.Syntax; + exports2.version = "4.0.1"; + }, + /* 1 */ + /***/ + function(module2, exports2, __webpack_require__) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var syntax_1 = __webpack_require__(2); + var CommentHandler = function() { + function CommentHandler2() { + this.attach = false; + this.comments = []; + this.stack = []; + this.leading = []; + this.trailing = []; + } + CommentHandler2.prototype.insertInnerComments = function(node, metadata) { + if (node.type === syntax_1.Syntax.BlockStatement && node.body.length === 0) { + var innerComments = []; + for (var i = this.leading.length - 1; i >= 0; --i) { + var entry = this.leading[i]; + if (metadata.end.offset >= entry.start) { + innerComments.unshift(entry.comment); + this.leading.splice(i, 1); + this.trailing.splice(i, 1); + } + } + if (innerComments.length) { + node.innerComments = innerComments; + } + } + }; + CommentHandler2.prototype.findTrailingComments = function(metadata) { + var trailingComments = []; + if (this.trailing.length > 0) { + for (var i = this.trailing.length - 1; i >= 0; --i) { + var entry_1 = this.trailing[i]; + if (entry_1.start >= metadata.end.offset) { + trailingComments.unshift(entry_1.comment); + } + } + this.trailing.length = 0; + return trailingComments; + } + var entry = this.stack[this.stack.length - 1]; + if (entry && entry.node.trailingComments) { + var firstComment = entry.node.trailingComments[0]; + if (firstComment && firstComment.range[0] >= metadata.end.offset) { + trailingComments = entry.node.trailingComments; + delete entry.node.trailingComments; + } + } + return trailingComments; + }; + CommentHandler2.prototype.findLeadingComments = function(metadata) { + var leadingComments = []; + var target; + while (this.stack.length > 0) { + var entry = this.stack[this.stack.length - 1]; + if (entry && entry.start >= metadata.start.offset) { + target = entry.node; + this.stack.pop(); + } else { + break; + } + } + if (target) { + var count = target.leadingComments ? target.leadingComments.length : 0; + for (var i = count - 1; i >= 0; --i) { + var comment = target.leadingComments[i]; + if (comment.range[1] <= metadata.start.offset) { + leadingComments.unshift(comment); + target.leadingComments.splice(i, 1); + } + } + if (target.leadingComments && target.leadingComments.length === 0) { + delete target.leadingComments; + } + return leadingComments; + } + for (var i = this.leading.length - 1; i >= 0; --i) { + var entry = this.leading[i]; + if (entry.start <= metadata.start.offset) { + leadingComments.unshift(entry.comment); + this.leading.splice(i, 1); + } + } + return leadingComments; + }; + CommentHandler2.prototype.visitNode = function(node, metadata) { + if (node.type === syntax_1.Syntax.Program && node.body.length > 0) { + return; + } + this.insertInnerComments(node, metadata); + var trailingComments = this.findTrailingComments(metadata); + var leadingComments = this.findLeadingComments(metadata); + if (leadingComments.length > 0) { + node.leadingComments = leadingComments; + } + if (trailingComments.length > 0) { + node.trailingComments = trailingComments; + } + this.stack.push({ + node, + start: metadata.start.offset + }); + }; + CommentHandler2.prototype.visitComment = function(node, metadata) { + var type = node.type[0] === "L" ? "Line" : "Block"; + var comment = { + type, + value: node.value + }; + if (node.range) { + comment.range = node.range; + } + if (node.loc) { + comment.loc = node.loc; + } + this.comments.push(comment); + if (this.attach) { + var entry = { + comment: { + type, + value: node.value, + range: [metadata.start.offset, metadata.end.offset] + }, + start: metadata.start.offset + }; + if (node.loc) { + entry.comment.loc = node.loc; + } + node.type = type; + this.leading.push(entry); + this.trailing.push(entry); + } + }; + CommentHandler2.prototype.visit = function(node, metadata) { + if (node.type === "LineComment") { + this.visitComment(node, metadata); + } else if (node.type === "BlockComment") { + this.visitComment(node, metadata); + } else if (this.attach) { + this.visitNode(node, metadata); + } + }; + return CommentHandler2; + }(); + exports2.CommentHandler = CommentHandler; + }, + /* 2 */ + /***/ + function(module2, exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Syntax = { + AssignmentExpression: "AssignmentExpression", + AssignmentPattern: "AssignmentPattern", + ArrayExpression: "ArrayExpression", + ArrayPattern: "ArrayPattern", + ArrowFunctionExpression: "ArrowFunctionExpression", + AwaitExpression: "AwaitExpression", + BlockStatement: "BlockStatement", + BinaryExpression: "BinaryExpression", + BreakStatement: "BreakStatement", + CallExpression: "CallExpression", + CatchClause: "CatchClause", + ClassBody: "ClassBody", + ClassDeclaration: "ClassDeclaration", + ClassExpression: "ClassExpression", + ConditionalExpression: "ConditionalExpression", + ContinueStatement: "ContinueStatement", + DoWhileStatement: "DoWhileStatement", + DebuggerStatement: "DebuggerStatement", + EmptyStatement: "EmptyStatement", + ExportAllDeclaration: "ExportAllDeclaration", + ExportDefaultDeclaration: "ExportDefaultDeclaration", + ExportNamedDeclaration: "ExportNamedDeclaration", + ExportSpecifier: "ExportSpecifier", + ExpressionStatement: "ExpressionStatement", + ForStatement: "ForStatement", + ForOfStatement: "ForOfStatement", + ForInStatement: "ForInStatement", + FunctionDeclaration: "FunctionDeclaration", + FunctionExpression: "FunctionExpression", + Identifier: "Identifier", + IfStatement: "IfStatement", + ImportDeclaration: "ImportDeclaration", + ImportDefaultSpecifier: "ImportDefaultSpecifier", + ImportNamespaceSpecifier: "ImportNamespaceSpecifier", + ImportSpecifier: "ImportSpecifier", + Literal: "Literal", + LabeledStatement: "LabeledStatement", + LogicalExpression: "LogicalExpression", + MemberExpression: "MemberExpression", + MetaProperty: "MetaProperty", + MethodDefinition: "MethodDefinition", + NewExpression: "NewExpression", + ObjectExpression: "ObjectExpression", + ObjectPattern: "ObjectPattern", + Program: "Program", + Property: "Property", + RestElement: "RestElement", + ReturnStatement: "ReturnStatement", + SequenceExpression: "SequenceExpression", + SpreadElement: "SpreadElement", + Super: "Super", + SwitchCase: "SwitchCase", + SwitchStatement: "SwitchStatement", + TaggedTemplateExpression: "TaggedTemplateExpression", + TemplateElement: "TemplateElement", + TemplateLiteral: "TemplateLiteral", + ThisExpression: "ThisExpression", + ThrowStatement: "ThrowStatement", + TryStatement: "TryStatement", + UnaryExpression: "UnaryExpression", + UpdateExpression: "UpdateExpression", + VariableDeclaration: "VariableDeclaration", + VariableDeclarator: "VariableDeclarator", + WhileStatement: "WhileStatement", + WithStatement: "WithStatement", + YieldExpression: "YieldExpression" + }; + }, + /* 3 */ + /***/ + function(module2, exports2, __webpack_require__) { + "use strict"; + var __extends2 = this && this.__extends || function() { + var extendStatics2 = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) { + d.__proto__ = b; + } || function(d, b) { + for (var p in b) + if (b.hasOwnProperty(p)) + d[p] = b[p]; + }; + return function(d, b) { + extendStatics2(d, b); + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + }(); + Object.defineProperty(exports2, "__esModule", { value: true }); + var character_1 = __webpack_require__(4); + var JSXNode = __webpack_require__(5); + var jsx_syntax_1 = __webpack_require__(6); + var Node2 = __webpack_require__(7); + var parser_1 = __webpack_require__(8); + var token_1 = __webpack_require__(13); + var xhtml_entities_1 = __webpack_require__(14); + token_1.TokenName[ + 100 + /* Identifier */ + ] = "JSXIdentifier"; + token_1.TokenName[ + 101 + /* Text */ + ] = "JSXText"; + function getQualifiedElementName(elementName) { + var qualifiedName; + switch (elementName.type) { + case jsx_syntax_1.JSXSyntax.JSXIdentifier: + var id = elementName; + qualifiedName = id.name; + break; + case jsx_syntax_1.JSXSyntax.JSXNamespacedName: + var ns = elementName; + qualifiedName = getQualifiedElementName(ns.namespace) + ":" + getQualifiedElementName(ns.name); + break; + case jsx_syntax_1.JSXSyntax.JSXMemberExpression: + var expr = elementName; + qualifiedName = getQualifiedElementName(expr.object) + "." + getQualifiedElementName(expr.property); + break; + default: + break; + } + return qualifiedName; + } + var JSXParser = function(_super) { + __extends2(JSXParser2, _super); + function JSXParser2(code, options, delegate) { + return _super.call(this, code, options, delegate) || this; + } + JSXParser2.prototype.parsePrimaryExpression = function() { + return this.match("<") ? this.parseJSXRoot() : _super.prototype.parsePrimaryExpression.call(this); + }; + JSXParser2.prototype.startJSX = function() { + this.scanner.index = this.startMarker.index; + this.scanner.lineNumber = this.startMarker.line; + this.scanner.lineStart = this.startMarker.index - this.startMarker.column; + }; + JSXParser2.prototype.finishJSX = function() { + this.nextToken(); + }; + JSXParser2.prototype.reenterJSX = function() { + this.startJSX(); + this.expectJSX("}"); + if (this.config.tokens) { + this.tokens.pop(); + } + }; + JSXParser2.prototype.createJSXNode = function() { + this.collectComments(); + return { + index: this.scanner.index, + line: this.scanner.lineNumber, + column: this.scanner.index - this.scanner.lineStart + }; + }; + JSXParser2.prototype.createJSXChildNode = function() { + return { + index: this.scanner.index, + line: this.scanner.lineNumber, + column: this.scanner.index - this.scanner.lineStart + }; + }; + JSXParser2.prototype.scanXHTMLEntity = function(quote) { + var result = "&"; + var valid = true; + var terminated = false; + var numeric = false; + var hex = false; + while (!this.scanner.eof() && valid && !terminated) { + var ch = this.scanner.source[this.scanner.index]; + if (ch === quote) { + break; + } + terminated = ch === ";"; + result += ch; + ++this.scanner.index; + if (!terminated) { + switch (result.length) { + case 2: + numeric = ch === "#"; + break; + case 3: + if (numeric) { + hex = ch === "x"; + valid = hex || character_1.Character.isDecimalDigit(ch.charCodeAt(0)); + numeric = numeric && !hex; + } + break; + default: + valid = valid && !(numeric && !character_1.Character.isDecimalDigit(ch.charCodeAt(0))); + valid = valid && !(hex && !character_1.Character.isHexDigit(ch.charCodeAt(0))); + break; + } + } + } + if (valid && terminated && result.length > 2) { + var str = result.substr(1, result.length - 2); + if (numeric && str.length > 1) { + result = String.fromCharCode(parseInt(str.substr(1), 10)); + } else if (hex && str.length > 2) { + result = String.fromCharCode(parseInt("0" + str.substr(1), 16)); + } else if (!numeric && !hex && xhtml_entities_1.XHTMLEntities[str]) { + result = xhtml_entities_1.XHTMLEntities[str]; + } + } + return result; + }; + JSXParser2.prototype.lexJSX = function() { + var cp = this.scanner.source.charCodeAt(this.scanner.index); + if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) { + var value = this.scanner.source[this.scanner.index++]; + return { + type: 7, + value, + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start: this.scanner.index - 1, + end: this.scanner.index + }; + } + if (cp === 34 || cp === 39) { + var start = this.scanner.index; + var quote = this.scanner.source[this.scanner.index++]; + var str = ""; + while (!this.scanner.eof()) { + var ch = this.scanner.source[this.scanner.index++]; + if (ch === quote) { + break; + } else if (ch === "&") { + str += this.scanXHTMLEntity(quote); + } else { + str += ch; + } + } + return { + type: 8, + value: str, + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start, + end: this.scanner.index + }; + } + if (cp === 46) { + var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1); + var n2 = this.scanner.source.charCodeAt(this.scanner.index + 2); + var value = n1 === 46 && n2 === 46 ? "..." : "."; + var start = this.scanner.index; + this.scanner.index += value.length; + return { + type: 7, + value, + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start, + end: this.scanner.index + }; + } + if (cp === 96) { + return { + type: 10, + value: "", + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start: this.scanner.index, + end: this.scanner.index + }; + } + if (character_1.Character.isIdentifierStart(cp) && cp !== 92) { + var start = this.scanner.index; + ++this.scanner.index; + while (!this.scanner.eof()) { + var ch = this.scanner.source.charCodeAt(this.scanner.index); + if (character_1.Character.isIdentifierPart(ch) && ch !== 92) { + ++this.scanner.index; + } else if (ch === 45) { + ++this.scanner.index; + } else { + break; + } + } + var id = this.scanner.source.slice(start, this.scanner.index); + return { + type: 100, + value: id, + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start, + end: this.scanner.index + }; + } + return this.scanner.lex(); + }; + JSXParser2.prototype.nextJSXToken = function() { + this.collectComments(); + this.startMarker.index = this.scanner.index; + this.startMarker.line = this.scanner.lineNumber; + this.startMarker.column = this.scanner.index - this.scanner.lineStart; + var token = this.lexJSX(); + this.lastMarker.index = this.scanner.index; + this.lastMarker.line = this.scanner.lineNumber; + this.lastMarker.column = this.scanner.index - this.scanner.lineStart; + if (this.config.tokens) { + this.tokens.push(this.convertToken(token)); + } + return token; + }; + JSXParser2.prototype.nextJSXText = function() { + this.startMarker.index = this.scanner.index; + this.startMarker.line = this.scanner.lineNumber; + this.startMarker.column = this.scanner.index - this.scanner.lineStart; + var start = this.scanner.index; + var text = ""; + while (!this.scanner.eof()) { + var ch = this.scanner.source[this.scanner.index]; + if (ch === "{" || ch === "<") { + break; + } + ++this.scanner.index; + text += ch; + if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) { + ++this.scanner.lineNumber; + if (ch === "\r" && this.scanner.source[this.scanner.index] === "\n") { + ++this.scanner.index; + } + this.scanner.lineStart = this.scanner.index; + } + } + this.lastMarker.index = this.scanner.index; + this.lastMarker.line = this.scanner.lineNumber; + this.lastMarker.column = this.scanner.index - this.scanner.lineStart; + var token = { + type: 101, + value: text, + lineNumber: this.scanner.lineNumber, + lineStart: this.scanner.lineStart, + start, + end: this.scanner.index + }; + if (text.length > 0 && this.config.tokens) { + this.tokens.push(this.convertToken(token)); + } + return token; + }; + JSXParser2.prototype.peekJSXToken = function() { + var state = this.scanner.saveState(); + this.scanner.scanComments(); + var next = this.lexJSX(); + this.scanner.restoreState(state); + return next; + }; + JSXParser2.prototype.expectJSX = function(value) { + var token = this.nextJSXToken(); + if (token.type !== 7 || token.value !== value) { + this.throwUnexpectedToken(token); + } + }; + JSXParser2.prototype.matchJSX = function(value) { + var next = this.peekJSXToken(); + return next.type === 7 && next.value === value; + }; + JSXParser2.prototype.parseJSXIdentifier = function() { + var node = this.createJSXNode(); + var token = this.nextJSXToken(); + if (token.type !== 100) { + this.throwUnexpectedToken(token); + } + return this.finalize(node, new JSXNode.JSXIdentifier(token.value)); + }; + JSXParser2.prototype.parseJSXElementName = function() { + var node = this.createJSXNode(); + var elementName = this.parseJSXIdentifier(); + if (this.matchJSX(":")) { + var namespace = elementName; + this.expectJSX(":"); + var name_1 = this.parseJSXIdentifier(); + elementName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_1)); + } else if (this.matchJSX(".")) { + while (this.matchJSX(".")) { + var object = elementName; + this.expectJSX("."); + var property = this.parseJSXIdentifier(); + elementName = this.finalize(node, new JSXNode.JSXMemberExpression(object, property)); + } + } + return elementName; + }; + JSXParser2.prototype.parseJSXAttributeName = function() { + var node = this.createJSXNode(); + var attributeName; + var identifier = this.parseJSXIdentifier(); + if (this.matchJSX(":")) { + var namespace = identifier; + this.expectJSX(":"); + var name_2 = this.parseJSXIdentifier(); + attributeName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_2)); + } else { + attributeName = identifier; + } + return attributeName; + }; + JSXParser2.prototype.parseJSXStringLiteralAttribute = function() { + var node = this.createJSXNode(); + var token = this.nextJSXToken(); + if (token.type !== 8) { + this.throwUnexpectedToken(token); + } + var raw = this.getTokenRaw(token); + return this.finalize(node, new Node2.Literal(token.value, raw)); + }; + JSXParser2.prototype.parseJSXExpressionAttribute = function() { + var node = this.createJSXNode(); + this.expectJSX("{"); + this.finishJSX(); + if (this.match("}")) { + this.tolerateError("JSX attributes must only be assigned a non-empty expression"); + } + var expression = this.parseAssignmentExpression(); + this.reenterJSX(); + return this.finalize(node, new JSXNode.JSXExpressionContainer(expression)); + }; + JSXParser2.prototype.parseJSXAttributeValue = function() { + return this.matchJSX("{") ? this.parseJSXExpressionAttribute() : this.matchJSX("<") ? this.parseJSXElement() : this.parseJSXStringLiteralAttribute(); + }; + JSXParser2.prototype.parseJSXNameValueAttribute = function() { + var node = this.createJSXNode(); + var name = this.parseJSXAttributeName(); + var value = null; + if (this.matchJSX("=")) { + this.expectJSX("="); + value = this.parseJSXAttributeValue(); + } + return this.finalize(node, new JSXNode.JSXAttribute(name, value)); + }; + JSXParser2.prototype.parseJSXSpreadAttribute = function() { + var node = this.createJSXNode(); + this.expectJSX("{"); + this.expectJSX("..."); + this.finishJSX(); + var argument = this.parseAssignmentExpression(); + this.reenterJSX(); + return this.finalize(node, new JSXNode.JSXSpreadAttribute(argument)); + }; + JSXParser2.prototype.parseJSXAttributes = function() { + var attributes = []; + while (!this.matchJSX("/") && !this.matchJSX(">")) { + var attribute = this.matchJSX("{") ? this.parseJSXSpreadAttribute() : this.parseJSXNameValueAttribute(); + attributes.push(attribute); + } + return attributes; + }; + JSXParser2.prototype.parseJSXOpeningElement = function() { + var node = this.createJSXNode(); + this.expectJSX("<"); + var name = this.parseJSXElementName(); + var attributes = this.parseJSXAttributes(); + var selfClosing = this.matchJSX("/"); + if (selfClosing) { + this.expectJSX("/"); + } + this.expectJSX(">"); + return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes)); + }; + JSXParser2.prototype.parseJSXBoundaryElement = function() { + var node = this.createJSXNode(); + this.expectJSX("<"); + if (this.matchJSX("/")) { + this.expectJSX("/"); + var name_3 = this.parseJSXElementName(); + this.expectJSX(">"); + return this.finalize(node, new JSXNode.JSXClosingElement(name_3)); + } + var name = this.parseJSXElementName(); + var attributes = this.parseJSXAttributes(); + var selfClosing = this.matchJSX("/"); + if (selfClosing) { + this.expectJSX("/"); + } + this.expectJSX(">"); + return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes)); + }; + JSXParser2.prototype.parseJSXEmptyExpression = function() { + var node = this.createJSXChildNode(); + this.collectComments(); + this.lastMarker.index = this.scanner.index; + this.lastMarker.line = this.scanner.lineNumber; + this.lastMarker.column = this.scanner.index - this.scanner.lineStart; + return this.finalize(node, new JSXNode.JSXEmptyExpression()); + }; + JSXParser2.prototype.parseJSXExpressionContainer = function() { + var node = this.createJSXNode(); + this.expectJSX("{"); + var expression; + if (this.matchJSX("}")) { + expression = this.parseJSXEmptyExpression(); + this.expectJSX("}"); + } else { + this.finishJSX(); + expression = this.parseAssignmentExpression(); + this.reenterJSX(); + } + return this.finalize(node, new JSXNode.JSXExpressionContainer(expression)); + }; + JSXParser2.prototype.parseJSXChildren = function() { + var children = []; + while (!this.scanner.eof()) { + var node = this.createJSXChildNode(); + var token = this.nextJSXText(); + if (token.start < token.end) { + var raw = this.getTokenRaw(token); + var child = this.finalize(node, new JSXNode.JSXText(token.value, raw)); + children.push(child); + } + if (this.scanner.source[this.scanner.index] === "{") { + var container = this.parseJSXExpressionContainer(); + children.push(container); + } else { + break; + } + } + return children; + }; + JSXParser2.prototype.parseComplexJSXElement = function(el) { + var stack = []; + while (!this.scanner.eof()) { + el.children = el.children.concat(this.parseJSXChildren()); + var node = this.createJSXChildNode(); + var element = this.parseJSXBoundaryElement(); + if (element.type === jsx_syntax_1.JSXSyntax.JSXOpeningElement) { + var opening = element; + if (opening.selfClosing) { + var child = this.finalize(node, new JSXNode.JSXElement(opening, [], null)); + el.children.push(child); + } else { + stack.push(el); + el = { node, opening, closing: null, children: [] }; + } + } + if (element.type === jsx_syntax_1.JSXSyntax.JSXClosingElement) { + el.closing = element; + var open_1 = getQualifiedElementName(el.opening.name); + var close_1 = getQualifiedElementName(el.closing.name); + if (open_1 !== close_1) { + this.tolerateError("Expected corresponding JSX closing tag for %0", open_1); + } + if (stack.length > 0) { + var child = this.finalize(el.node, new JSXNode.JSXElement(el.opening, el.children, el.closing)); + el = stack[stack.length - 1]; + el.children.push(child); + stack.pop(); + } else { + break; + } + } + } + return el; + }; + JSXParser2.prototype.parseJSXElement = function() { + var node = this.createJSXNode(); + var opening = this.parseJSXOpeningElement(); + var children = []; + var closing = null; + if (!opening.selfClosing) { + var el = this.parseComplexJSXElement({ node, opening, closing, children }); + children = el.children; + closing = el.closing; + } + return this.finalize(node, new JSXNode.JSXElement(opening, children, closing)); + }; + JSXParser2.prototype.parseJSXRoot = function() { + if (this.config.tokens) { + this.tokens.pop(); + } + this.startJSX(); + var element = this.parseJSXElement(); + this.finishJSX(); + return element; + }; + JSXParser2.prototype.isStartOfExpression = function() { + return _super.prototype.isStartOfExpression.call(this) || this.match("<"); + }; + return JSXParser2; + }(parser_1.Parser); + exports2.JSXParser = JSXParser; + }, + /* 4 */ + /***/ + function(module2, exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var Regex = { + // Unicode v8.0.0 NonAsciiIdentifierStart: + NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/, + // Unicode v8.0.0 NonAsciiIdentifierPart: + NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/ + }; + exports2.Character = { + /* tslint:disable:no-bitwise */ + fromCodePoint: function(cp) { + return cp < 65536 ? String.fromCharCode(cp) : String.fromCharCode(55296 + (cp - 65536 >> 10)) + String.fromCharCode(56320 + (cp - 65536 & 1023)); + }, + // https://tc39.github.io/ecma262/#sec-white-space + isWhiteSpace: function(cp) { + return cp === 32 || cp === 9 || cp === 11 || cp === 12 || cp === 160 || cp >= 5760 && [5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288, 65279].indexOf(cp) >= 0; + }, + // https://tc39.github.io/ecma262/#sec-line-terminators + isLineTerminator: function(cp) { + return cp === 10 || cp === 13 || cp === 8232 || cp === 8233; + }, + // https://tc39.github.io/ecma262/#sec-names-and-keywords + isIdentifierStart: function(cp) { + return cp === 36 || cp === 95 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 92 || cp >= 128 && Regex.NonAsciiIdentifierStart.test(exports2.Character.fromCodePoint(cp)); + }, + isIdentifierPart: function(cp) { + return cp === 36 || cp === 95 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp >= 48 && cp <= 57 || cp === 92 || cp >= 128 && Regex.NonAsciiIdentifierPart.test(exports2.Character.fromCodePoint(cp)); + }, + // https://tc39.github.io/ecma262/#sec-literals-numeric-literals + isDecimalDigit: function(cp) { + return cp >= 48 && cp <= 57; + }, + isHexDigit: function(cp) { + return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 70 || cp >= 97 && cp <= 102; + }, + isOctalDigit: function(cp) { + return cp >= 48 && cp <= 55; + } + }; + }, + /* 5 */ + /***/ + function(module2, exports2, __webpack_require__) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var jsx_syntax_1 = __webpack_require__(6); + var JSXClosingElement = function() { + function JSXClosingElement2(name) { + this.type = jsx_syntax_1.JSXSyntax.JSXClosingElement; + this.name = name; + } + return JSXClosingElement2; + }(); + exports2.JSXClosingElement = JSXClosingElement; + var JSXElement = function() { + function JSXElement2(openingElement, children, closingElement) { + this.type = jsx_syntax_1.JSXSyntax.JSXElement; + this.openingElement = openingElement; + this.children = children; + this.closingElement = closingElement; + } + return JSXElement2; + }(); + exports2.JSXElement = JSXElement; + var JSXEmptyExpression = function() { + function JSXEmptyExpression2() { + this.type = jsx_syntax_1.JSXSyntax.JSXEmptyExpression; + } + return JSXEmptyExpression2; + }(); + exports2.JSXEmptyExpression = JSXEmptyExpression; + var JSXExpressionContainer = function() { + function JSXExpressionContainer2(expression) { + this.type = jsx_syntax_1.JSXSyntax.JSXExpressionContainer; + this.expression = expression; + } + return JSXExpressionContainer2; + }(); + exports2.JSXExpressionContainer = JSXExpressionContainer; + var JSXIdentifier = function() { + function JSXIdentifier2(name) { + this.type = jsx_syntax_1.JSXSyntax.JSXIdentifier; + this.name = name; + } + return JSXIdentifier2; + }(); + exports2.JSXIdentifier = JSXIdentifier; + var JSXMemberExpression = function() { + function JSXMemberExpression2(object, property) { + this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression; + this.object = object; + this.property = property; + } + return JSXMemberExpression2; + }(); + exports2.JSXMemberExpression = JSXMemberExpression; + var JSXAttribute = function() { + function JSXAttribute2(name, value) { + this.type = jsx_syntax_1.JSXSyntax.JSXAttribute; + this.name = name; + this.value = value; + } + return JSXAttribute2; + }(); + exports2.JSXAttribute = JSXAttribute; + var JSXNamespacedName = function() { + function JSXNamespacedName2(namespace, name) { + this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName; + this.namespace = namespace; + this.name = name; + } + return JSXNamespacedName2; + }(); + exports2.JSXNamespacedName = JSXNamespacedName; + var JSXOpeningElement = function() { + function JSXOpeningElement2(name, selfClosing, attributes) { + this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement; + this.name = name; + this.selfClosing = selfClosing; + this.attributes = attributes; + } + return JSXOpeningElement2; + }(); + exports2.JSXOpeningElement = JSXOpeningElement; + var JSXSpreadAttribute = function() { + function JSXSpreadAttribute2(argument) { + this.type = jsx_syntax_1.JSXSyntax.JSXSpreadAttribute; + this.argument = argument; + } + return JSXSpreadAttribute2; + }(); + exports2.JSXSpreadAttribute = JSXSpreadAttribute; + var JSXText = function() { + function JSXText2(value, raw) { + this.type = jsx_syntax_1.JSXSyntax.JSXText; + this.value = value; + this.raw = raw; + } + return JSXText2; + }(); + exports2.JSXText = JSXText; + }, + /* 6 */ + /***/ + function(module2, exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.JSXSyntax = { + JSXAttribute: "JSXAttribute", + JSXClosingElement: "JSXClosingElement", + JSXElement: "JSXElement", + JSXEmptyExpression: "JSXEmptyExpression", + JSXExpressionContainer: "JSXExpressionContainer", + JSXIdentifier: "JSXIdentifier", + JSXMemberExpression: "JSXMemberExpression", + JSXNamespacedName: "JSXNamespacedName", + JSXOpeningElement: "JSXOpeningElement", + JSXSpreadAttribute: "JSXSpreadAttribute", + JSXText: "JSXText" + }; + }, + /* 7 */ + /***/ + function(module2, exports2, __webpack_require__) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var syntax_1 = __webpack_require__(2); + var ArrayExpression = function() { + function ArrayExpression2(elements) { + this.type = syntax_1.Syntax.ArrayExpression; + this.elements = elements; + } + return ArrayExpression2; + }(); + exports2.ArrayExpression = ArrayExpression; + var ArrayPattern = function() { + function ArrayPattern2(elements) { + this.type = syntax_1.Syntax.ArrayPattern; + this.elements = elements; + } + return ArrayPattern2; + }(); + exports2.ArrayPattern = ArrayPattern; + var ArrowFunctionExpression = function() { + function ArrowFunctionExpression2(params, body, expression) { + this.type = syntax_1.Syntax.ArrowFunctionExpression; + this.id = null; + this.params = params; + this.body = body; + this.generator = false; + this.expression = expression; + this.async = false; + } + return ArrowFunctionExpression2; + }(); + exports2.ArrowFunctionExpression = ArrowFunctionExpression; + var AssignmentExpression = function() { + function AssignmentExpression2(operator, left2, right2) { + this.type = syntax_1.Syntax.AssignmentExpression; + this.operator = operator; + this.left = left2; + this.right = right2; + } + return AssignmentExpression2; + }(); + exports2.AssignmentExpression = AssignmentExpression; + var AssignmentPattern = function() { + function AssignmentPattern2(left2, right2) { + this.type = syntax_1.Syntax.AssignmentPattern; + this.left = left2; + this.right = right2; + } + return AssignmentPattern2; + }(); + exports2.AssignmentPattern = AssignmentPattern; + var AsyncArrowFunctionExpression = function() { + function AsyncArrowFunctionExpression2(params, body, expression) { + this.type = syntax_1.Syntax.ArrowFunctionExpression; + this.id = null; + this.params = params; + this.body = body; + this.generator = false; + this.expression = expression; + this.async = true; + } + return AsyncArrowFunctionExpression2; + }(); + exports2.AsyncArrowFunctionExpression = AsyncArrowFunctionExpression; + var AsyncFunctionDeclaration = function() { + function AsyncFunctionDeclaration2(id, params, body) { + this.type = syntax_1.Syntax.FunctionDeclaration; + this.id = id; + this.params = params; + this.body = body; + this.generator = false; + this.expression = false; + this.async = true; + } + return AsyncFunctionDeclaration2; + }(); + exports2.AsyncFunctionDeclaration = AsyncFunctionDeclaration; + var AsyncFunctionExpression = function() { + function AsyncFunctionExpression2(id, params, body) { + this.type = syntax_1.Syntax.FunctionExpression; + this.id = id; + this.params = params; + this.body = body; + this.generator = false; + this.expression = false; + this.async = true; + } + return AsyncFunctionExpression2; + }(); + exports2.AsyncFunctionExpression = AsyncFunctionExpression; + var AwaitExpression = function() { + function AwaitExpression2(argument) { + this.type = syntax_1.Syntax.AwaitExpression; + this.argument = argument; + } + return AwaitExpression2; + }(); + exports2.AwaitExpression = AwaitExpression; + var BinaryExpression = function() { + function BinaryExpression2(operator, left2, right2) { + var logical = operator === "||" || operator === "&&"; + this.type = logical ? syntax_1.Syntax.LogicalExpression : syntax_1.Syntax.BinaryExpression; + this.operator = operator; + this.left = left2; + this.right = right2; + } + return BinaryExpression2; + }(); + exports2.BinaryExpression = BinaryExpression; + var BlockStatement = function() { + function BlockStatement2(body) { + this.type = syntax_1.Syntax.BlockStatement; + this.body = body; + } + return BlockStatement2; + }(); + exports2.BlockStatement = BlockStatement; + var BreakStatement = function() { + function BreakStatement2(label) { + this.type = syntax_1.Syntax.BreakStatement; + this.label = label; + } + return BreakStatement2; + }(); + exports2.BreakStatement = BreakStatement; + var CallExpression = function() { + function CallExpression2(callee, args) { + this.type = syntax_1.Syntax.CallExpression; + this.callee = callee; + this.arguments = args; + } + return CallExpression2; + }(); + exports2.CallExpression = CallExpression; + var CatchClause = function() { + function CatchClause2(param, body) { + this.type = syntax_1.Syntax.CatchClause; + this.param = param; + this.body = body; + } + return CatchClause2; + }(); + exports2.CatchClause = CatchClause; + var ClassBody = function() { + function ClassBody2(body) { + this.type = syntax_1.Syntax.ClassBody; + this.body = body; + } + return ClassBody2; + }(); + exports2.ClassBody = ClassBody; + var ClassDeclaration = function() { + function ClassDeclaration2(id, superClass, body) { + this.type = syntax_1.Syntax.ClassDeclaration; + this.id = id; + this.superClass = superClass; + this.body = body; + } + return ClassDeclaration2; + }(); + exports2.ClassDeclaration = ClassDeclaration; + var ClassExpression = function() { + function ClassExpression2(id, superClass, body) { + this.type = syntax_1.Syntax.ClassExpression; + this.id = id; + this.superClass = superClass; + this.body = body; + } + return ClassExpression2; + }(); + exports2.ClassExpression = ClassExpression; + var ComputedMemberExpression = function() { + function ComputedMemberExpression2(object, property) { + this.type = syntax_1.Syntax.MemberExpression; + this.computed = true; + this.object = object; + this.property = property; + } + return ComputedMemberExpression2; + }(); + exports2.ComputedMemberExpression = ComputedMemberExpression; + var ConditionalExpression = function() { + function ConditionalExpression2(test, consequent, alternate) { + this.type = syntax_1.Syntax.ConditionalExpression; + this.test = test; + this.consequent = consequent; + this.alternate = alternate; + } + return ConditionalExpression2; + }(); + exports2.ConditionalExpression = ConditionalExpression; + var ContinueStatement = function() { + function ContinueStatement2(label) { + this.type = syntax_1.Syntax.ContinueStatement; + this.label = label; + } + return ContinueStatement2; + }(); + exports2.ContinueStatement = ContinueStatement; + var DebuggerStatement = function() { + function DebuggerStatement2() { + this.type = syntax_1.Syntax.DebuggerStatement; + } + return DebuggerStatement2; + }(); + exports2.DebuggerStatement = DebuggerStatement; + var Directive = function() { + function Directive2(expression, directive) { + this.type = syntax_1.Syntax.ExpressionStatement; + this.expression = expression; + this.directive = directive; + } + return Directive2; + }(); + exports2.Directive = Directive; + var DoWhileStatement = function() { + function DoWhileStatement2(body, test) { + this.type = syntax_1.Syntax.DoWhileStatement; + this.body = body; + this.test = test; + } + return DoWhileStatement2; + }(); + exports2.DoWhileStatement = DoWhileStatement; + var EmptyStatement = function() { + function EmptyStatement2() { + this.type = syntax_1.Syntax.EmptyStatement; + } + return EmptyStatement2; + }(); + exports2.EmptyStatement = EmptyStatement; + var ExportAllDeclaration = function() { + function ExportAllDeclaration2(source) { + this.type = syntax_1.Syntax.ExportAllDeclaration; + this.source = source; + } + return ExportAllDeclaration2; + }(); + exports2.ExportAllDeclaration = ExportAllDeclaration; + var ExportDefaultDeclaration = function() { + function ExportDefaultDeclaration2(declaration) { + this.type = syntax_1.Syntax.ExportDefaultDeclaration; + this.declaration = declaration; + } + return ExportDefaultDeclaration2; + }(); + exports2.ExportDefaultDeclaration = ExportDefaultDeclaration; + var ExportNamedDeclaration = function() { + function ExportNamedDeclaration2(declaration, specifiers, source) { + this.type = syntax_1.Syntax.ExportNamedDeclaration; + this.declaration = declaration; + this.specifiers = specifiers; + this.source = source; + } + return ExportNamedDeclaration2; + }(); + exports2.ExportNamedDeclaration = ExportNamedDeclaration; + var ExportSpecifier = function() { + function ExportSpecifier2(local, exported) { + this.type = syntax_1.Syntax.ExportSpecifier; + this.exported = exported; + this.local = local; + } + return ExportSpecifier2; + }(); + exports2.ExportSpecifier = ExportSpecifier; + var ExpressionStatement = function() { + function ExpressionStatement2(expression) { + this.type = syntax_1.Syntax.ExpressionStatement; + this.expression = expression; + } + return ExpressionStatement2; + }(); + exports2.ExpressionStatement = ExpressionStatement; + var ForInStatement = function() { + function ForInStatement2(left2, right2, body) { + this.type = syntax_1.Syntax.ForInStatement; + this.left = left2; + this.right = right2; + this.body = body; + this.each = false; + } + return ForInStatement2; + }(); + exports2.ForInStatement = ForInStatement; + var ForOfStatement = function() { + function ForOfStatement2(left2, right2, body) { + this.type = syntax_1.Syntax.ForOfStatement; + this.left = left2; + this.right = right2; + this.body = body; + } + return ForOfStatement2; + }(); + exports2.ForOfStatement = ForOfStatement; + var ForStatement = function() { + function ForStatement2(init, test, update, body) { + this.type = syntax_1.Syntax.ForStatement; + this.init = init; + this.test = test; + this.update = update; + this.body = body; + } + return ForStatement2; + }(); + exports2.ForStatement = ForStatement; + var FunctionDeclaration = function() { + function FunctionDeclaration2(id, params, body, generator) { + this.type = syntax_1.Syntax.FunctionDeclaration; + this.id = id; + this.params = params; + this.body = body; + this.generator = generator; + this.expression = false; + this.async = false; + } + return FunctionDeclaration2; + }(); + exports2.FunctionDeclaration = FunctionDeclaration; + var FunctionExpression = function() { + function FunctionExpression2(id, params, body, generator) { + this.type = syntax_1.Syntax.FunctionExpression; + this.id = id; + this.params = params; + this.body = body; + this.generator = generator; + this.expression = false; + this.async = false; + } + return FunctionExpression2; + }(); + exports2.FunctionExpression = FunctionExpression; + var Identifier = function() { + function Identifier2(name) { + this.type = syntax_1.Syntax.Identifier; + this.name = name; + } + return Identifier2; + }(); + exports2.Identifier = Identifier; + var IfStatement = function() { + function IfStatement2(test, consequent, alternate) { + this.type = syntax_1.Syntax.IfStatement; + this.test = test; + this.consequent = consequent; + this.alternate = alternate; + } + return IfStatement2; + }(); + exports2.IfStatement = IfStatement; + var ImportDeclaration = function() { + function ImportDeclaration2(specifiers, source) { + this.type = syntax_1.Syntax.ImportDeclaration; + this.specifiers = specifiers; + this.source = source; + } + return ImportDeclaration2; + }(); + exports2.ImportDeclaration = ImportDeclaration; + var ImportDefaultSpecifier = function() { + function ImportDefaultSpecifier2(local) { + this.type = syntax_1.Syntax.ImportDefaultSpecifier; + this.local = local; + } + return ImportDefaultSpecifier2; + }(); + exports2.ImportDefaultSpecifier = ImportDefaultSpecifier; + var ImportNamespaceSpecifier = function() { + function ImportNamespaceSpecifier2(local) { + this.type = syntax_1.Syntax.ImportNamespaceSpecifier; + this.local = local; + } + return ImportNamespaceSpecifier2; + }(); + exports2.ImportNamespaceSpecifier = ImportNamespaceSpecifier; + var ImportSpecifier = function() { + function ImportSpecifier2(local, imported) { + this.type = syntax_1.Syntax.ImportSpecifier; + this.local = local; + this.imported = imported; + } + return ImportSpecifier2; + }(); + exports2.ImportSpecifier = ImportSpecifier; + var LabeledStatement = function() { + function LabeledStatement2(label, body) { + this.type = syntax_1.Syntax.LabeledStatement; + this.label = label; + this.body = body; + } + return LabeledStatement2; + }(); + exports2.LabeledStatement = LabeledStatement; + var Literal = function() { + function Literal2(value, raw) { + this.type = syntax_1.Syntax.Literal; + this.value = value; + this.raw = raw; + } + return Literal2; + }(); + exports2.Literal = Literal; + var MetaProperty = function() { + function MetaProperty2(meta, property) { + this.type = syntax_1.Syntax.MetaProperty; + this.meta = meta; + this.property = property; + } + return MetaProperty2; + }(); + exports2.MetaProperty = MetaProperty; + var MethodDefinition = function() { + function MethodDefinition2(key, computed, value, kind, isStatic) { + this.type = syntax_1.Syntax.MethodDefinition; + this.key = key; + this.computed = computed; + this.value = value; + this.kind = kind; + this.static = isStatic; + } + return MethodDefinition2; + }(); + exports2.MethodDefinition = MethodDefinition; + var Module = function() { + function Module2(body) { + this.type = syntax_1.Syntax.Program; + this.body = body; + this.sourceType = "module"; + } + return Module2; + }(); + exports2.Module = Module; + var NewExpression = function() { + function NewExpression2(callee, args) { + this.type = syntax_1.Syntax.NewExpression; + this.callee = callee; + this.arguments = args; + } + return NewExpression2; + }(); + exports2.NewExpression = NewExpression; + var ObjectExpression = function() { + function ObjectExpression2(properties) { + this.type = syntax_1.Syntax.ObjectExpression; + this.properties = properties; + } + return ObjectExpression2; + }(); + exports2.ObjectExpression = ObjectExpression; + var ObjectPattern = function() { + function ObjectPattern2(properties) { + this.type = syntax_1.Syntax.ObjectPattern; + this.properties = properties; + } + return ObjectPattern2; + }(); + exports2.ObjectPattern = ObjectPattern; + var Property = function() { + function Property2(kind, key, computed, value, method, shorthand) { + this.type = syntax_1.Syntax.Property; + this.key = key; + this.computed = computed; + this.value = value; + this.kind = kind; + this.method = method; + this.shorthand = shorthand; + } + return Property2; + }(); + exports2.Property = Property; + var RegexLiteral = function() { + function RegexLiteral2(value, raw, pattern, flags) { + this.type = syntax_1.Syntax.Literal; + this.value = value; + this.raw = raw; + this.regex = { pattern, flags }; + } + return RegexLiteral2; + }(); + exports2.RegexLiteral = RegexLiteral; + var RestElement = function() { + function RestElement2(argument) { + this.type = syntax_1.Syntax.RestElement; + this.argument = argument; + } + return RestElement2; + }(); + exports2.RestElement = RestElement; + var ReturnStatement = function() { + function ReturnStatement2(argument) { + this.type = syntax_1.Syntax.ReturnStatement; + this.argument = argument; + } + return ReturnStatement2; + }(); + exports2.ReturnStatement = ReturnStatement; + var Script = function() { + function Script2(body) { + this.type = syntax_1.Syntax.Program; + this.body = body; + this.sourceType = "script"; + } + return Script2; + }(); + exports2.Script = Script; + var SequenceExpression = function() { + function SequenceExpression2(expressions) { + this.type = syntax_1.Syntax.SequenceExpression; + this.expressions = expressions; + } + return SequenceExpression2; + }(); + exports2.SequenceExpression = SequenceExpression; + var SpreadElement = function() { + function SpreadElement2(argument) { + this.type = syntax_1.Syntax.SpreadElement; + this.argument = argument; + } + return SpreadElement2; + }(); + exports2.SpreadElement = SpreadElement; + var StaticMemberExpression = function() { + function StaticMemberExpression2(object, property) { + this.type = syntax_1.Syntax.MemberExpression; + this.computed = false; + this.object = object; + this.property = property; + } + return StaticMemberExpression2; + }(); + exports2.StaticMemberExpression = StaticMemberExpression; + var Super = function() { + function Super2() { + this.type = syntax_1.Syntax.Super; + } + return Super2; + }(); + exports2.Super = Super; + var SwitchCase = function() { + function SwitchCase2(test, consequent) { + this.type = syntax_1.Syntax.SwitchCase; + this.test = test; + this.consequent = consequent; + } + return SwitchCase2; + }(); + exports2.SwitchCase = SwitchCase; + var SwitchStatement = function() { + function SwitchStatement2(discriminant, cases) { + this.type = syntax_1.Syntax.SwitchStatement; + this.discriminant = discriminant; + this.cases = cases; + } + return SwitchStatement2; + }(); + exports2.SwitchStatement = SwitchStatement; + var TaggedTemplateExpression = function() { + function TaggedTemplateExpression2(tag, quasi) { + this.type = syntax_1.Syntax.TaggedTemplateExpression; + this.tag = tag; + this.quasi = quasi; + } + return TaggedTemplateExpression2; + }(); + exports2.TaggedTemplateExpression = TaggedTemplateExpression; + var TemplateElement = function() { + function TemplateElement2(value, tail) { + this.type = syntax_1.Syntax.TemplateElement; + this.value = value; + this.tail = tail; + } + return TemplateElement2; + }(); + exports2.TemplateElement = TemplateElement; + var TemplateLiteral = function() { + function TemplateLiteral2(quasis, expressions) { + this.type = syntax_1.Syntax.TemplateLiteral; + this.quasis = quasis; + this.expressions = expressions; + } + return TemplateLiteral2; + }(); + exports2.TemplateLiteral = TemplateLiteral; + var ThisExpression = function() { + function ThisExpression2() { + this.type = syntax_1.Syntax.ThisExpression; + } + return ThisExpression2; + }(); + exports2.ThisExpression = ThisExpression; + var ThrowStatement = function() { + function ThrowStatement2(argument) { + this.type = syntax_1.Syntax.ThrowStatement; + this.argument = argument; + } + return ThrowStatement2; + }(); + exports2.ThrowStatement = ThrowStatement; + var TryStatement = function() { + function TryStatement2(block, handler, finalizer) { + this.type = syntax_1.Syntax.TryStatement; + this.block = block; + this.handler = handler; + this.finalizer = finalizer; + } + return TryStatement2; + }(); + exports2.TryStatement = TryStatement; + var UnaryExpression = function() { + function UnaryExpression2(operator, argument) { + this.type = syntax_1.Syntax.UnaryExpression; + this.operator = operator; + this.argument = argument; + this.prefix = true; + } + return UnaryExpression2; + }(); + exports2.UnaryExpression = UnaryExpression; + var UpdateExpression = function() { + function UpdateExpression2(operator, argument, prefix) { + this.type = syntax_1.Syntax.UpdateExpression; + this.operator = operator; + this.argument = argument; + this.prefix = prefix; + } + return UpdateExpression2; + }(); + exports2.UpdateExpression = UpdateExpression; + var VariableDeclaration = function() { + function VariableDeclaration2(declarations, kind) { + this.type = syntax_1.Syntax.VariableDeclaration; + this.declarations = declarations; + this.kind = kind; + } + return VariableDeclaration2; + }(); + exports2.VariableDeclaration = VariableDeclaration; + var VariableDeclarator = function() { + function VariableDeclarator2(id, init) { + this.type = syntax_1.Syntax.VariableDeclarator; + this.id = id; + this.init = init; + } + return VariableDeclarator2; + }(); + exports2.VariableDeclarator = VariableDeclarator; + var WhileStatement = function() { + function WhileStatement2(test, body) { + this.type = syntax_1.Syntax.WhileStatement; + this.test = test; + this.body = body; + } + return WhileStatement2; + }(); + exports2.WhileStatement = WhileStatement; + var WithStatement = function() { + function WithStatement2(object, body) { + this.type = syntax_1.Syntax.WithStatement; + this.object = object; + this.body = body; + } + return WithStatement2; + }(); + exports2.WithStatement = WithStatement; + var YieldExpression = function() { + function YieldExpression2(argument, delegate) { + this.type = syntax_1.Syntax.YieldExpression; + this.argument = argument; + this.delegate = delegate; + } + return YieldExpression2; + }(); + exports2.YieldExpression = YieldExpression; + }, + /* 8 */ + /***/ + function(module2, exports2, __webpack_require__) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var assert_1 = __webpack_require__(9); + var error_handler_1 = __webpack_require__(10); + var messages_1 = __webpack_require__(11); + var Node2 = __webpack_require__(7); + var scanner_1 = __webpack_require__(12); + var syntax_1 = __webpack_require__(2); + var token_1 = __webpack_require__(13); + var ArrowParameterPlaceHolder = "ArrowParameterPlaceHolder"; + var Parser2 = function() { + function Parser3(code, options, delegate) { + if (options === void 0) { + options = {}; + } + this.config = { + range: typeof options.range === "boolean" && options.range, + loc: typeof options.loc === "boolean" && options.loc, + source: null, + tokens: typeof options.tokens === "boolean" && options.tokens, + comment: typeof options.comment === "boolean" && options.comment, + tolerant: typeof options.tolerant === "boolean" && options.tolerant + }; + if (this.config.loc && options.source && options.source !== null) { + this.config.source = String(options.source); + } + this.delegate = delegate; + this.errorHandler = new error_handler_1.ErrorHandler(); + this.errorHandler.tolerant = this.config.tolerant; + this.scanner = new scanner_1.Scanner(code, this.errorHandler); + this.scanner.trackComment = this.config.comment; + this.operatorPrecedence = { + ")": 0, + ";": 0, + ",": 0, + "=": 0, + "]": 0, + "||": 1, + "&&": 2, + "|": 3, + "^": 4, + "&": 5, + "==": 6, + "!=": 6, + "===": 6, + "!==": 6, + "<": 7, + ">": 7, + "<=": 7, + ">=": 7, + "<<": 8, + ">>": 8, + ">>>": 8, + "+": 9, + "-": 9, + "*": 11, + "/": 11, + "%": 11 + }; + this.lookahead = { + type: 2, + value: "", + lineNumber: this.scanner.lineNumber, + lineStart: 0, + start: 0, + end: 0 + }; + this.hasLineTerminator = false; + this.context = { + isModule: false, + await: false, + allowIn: true, + allowStrictDirective: true, + allowYield: true, + firstCoverInitializedNameError: null, + isAssignmentTarget: false, + isBindingElement: false, + inFunctionBody: false, + inIteration: false, + inSwitch: false, + labelSet: {}, + strict: false + }; + this.tokens = []; + this.startMarker = { + index: 0, + line: this.scanner.lineNumber, + column: 0 + }; + this.lastMarker = { + index: 0, + line: this.scanner.lineNumber, + column: 0 + }; + this.nextToken(); + this.lastMarker = { + index: this.scanner.index, + line: this.scanner.lineNumber, + column: this.scanner.index - this.scanner.lineStart + }; + } + Parser3.prototype.throwError = function(messageFormat) { + var values = []; + for (var _i = 1; _i < arguments.length; _i++) { + values[_i - 1] = arguments[_i]; + } + var args = Array.prototype.slice.call(arguments, 1); + var msg = messageFormat.replace(/%(\d)/g, function(whole, idx) { + assert_1.assert(idx < args.length, "Message reference must be in range"); + return args[idx]; + }); + var index = this.lastMarker.index; + var line = this.lastMarker.line; + var column = this.lastMarker.column + 1; + throw this.errorHandler.createError(index, line, column, msg); + }; + Parser3.prototype.tolerateError = function(messageFormat) { + var values = []; + for (var _i = 1; _i < arguments.length; _i++) { + values[_i - 1] = arguments[_i]; + } + var args = Array.prototype.slice.call(arguments, 1); + var msg = messageFormat.replace(/%(\d)/g, function(whole, idx) { + assert_1.assert(idx < args.length, "Message reference must be in range"); + return args[idx]; + }); + var index = this.lastMarker.index; + var line = this.scanner.lineNumber; + var column = this.lastMarker.column + 1; + this.errorHandler.tolerateError(index, line, column, msg); + }; + Parser3.prototype.unexpectedTokenError = function(token, message) { + var msg = message || messages_1.Messages.UnexpectedToken; + var value; + if (token) { + if (!message) { + msg = token.type === 2 ? messages_1.Messages.UnexpectedEOS : token.type === 3 ? messages_1.Messages.UnexpectedIdentifier : token.type === 6 ? messages_1.Messages.UnexpectedNumber : token.type === 8 ? messages_1.Messages.UnexpectedString : token.type === 10 ? messages_1.Messages.UnexpectedTemplate : messages_1.Messages.UnexpectedToken; + if (token.type === 4) { + if (this.scanner.isFutureReservedWord(token.value)) { + msg = messages_1.Messages.UnexpectedReserved; + } else if (this.context.strict && this.scanner.isStrictModeReservedWord(token.value)) { + msg = messages_1.Messages.StrictReservedWord; + } + } + } + value = token.value; + } else { + value = "ILLEGAL"; + } + msg = msg.replace("%0", value); + if (token && typeof token.lineNumber === "number") { + var index = token.start; + var line = token.lineNumber; + var lastMarkerLineStart = this.lastMarker.index - this.lastMarker.column; + var column = token.start - lastMarkerLineStart + 1; + return this.errorHandler.createError(index, line, column, msg); + } else { + var index = this.lastMarker.index; + var line = this.lastMarker.line; + var column = this.lastMarker.column + 1; + return this.errorHandler.createError(index, line, column, msg); + } + }; + Parser3.prototype.throwUnexpectedToken = function(token, message) { + throw this.unexpectedTokenError(token, message); + }; + Parser3.prototype.tolerateUnexpectedToken = function(token, message) { + this.errorHandler.tolerate(this.unexpectedTokenError(token, message)); + }; + Parser3.prototype.collectComments = function() { + if (!this.config.comment) { + this.scanner.scanComments(); + } else { + var comments = this.scanner.scanComments(); + if (comments.length > 0 && this.delegate) { + for (var i = 0; i < comments.length; ++i) { + var e = comments[i]; + var node = void 0; + node = { + type: e.multiLine ? "BlockComment" : "LineComment", + value: this.scanner.source.slice(e.slice[0], e.slice[1]) + }; + if (this.config.range) { + node.range = e.range; + } + if (this.config.loc) { + node.loc = e.loc; + } + var metadata = { + start: { + line: e.loc.start.line, + column: e.loc.start.column, + offset: e.range[0] + }, + end: { + line: e.loc.end.line, + column: e.loc.end.column, + offset: e.range[1] + } + }; + this.delegate(node, metadata); + } + } + } + }; + Parser3.prototype.getTokenRaw = function(token) { + return this.scanner.source.slice(token.start, token.end); + }; + Parser3.prototype.convertToken = function(token) { + var t = { + type: token_1.TokenName[token.type], + value: this.getTokenRaw(token) + }; + if (this.config.range) { + t.range = [token.start, token.end]; + } + if (this.config.loc) { + t.loc = { + start: { + line: this.startMarker.line, + column: this.startMarker.column + }, + end: { + line: this.scanner.lineNumber, + column: this.scanner.index - this.scanner.lineStart + } + }; + } + if (token.type === 9) { + var pattern = token.pattern; + var flags = token.flags; + t.regex = { pattern, flags }; + } + return t; + }; + Parser3.prototype.nextToken = function() { + var token = this.lookahead; + this.lastMarker.index = this.scanner.index; + this.lastMarker.line = this.scanner.lineNumber; + this.lastMarker.column = this.scanner.index - this.scanner.lineStart; + this.collectComments(); + if (this.scanner.index !== this.startMarker.index) { + this.startMarker.index = this.scanner.index; + this.startMarker.line = this.scanner.lineNumber; + this.startMarker.column = this.scanner.index - this.scanner.lineStart; + } + var next = this.scanner.lex(); + this.hasLineTerminator = token.lineNumber !== next.lineNumber; + if (next && this.context.strict && next.type === 3) { + if (this.scanner.isStrictModeReservedWord(next.value)) { + next.type = 4; + } + } + this.lookahead = next; + if (this.config.tokens && next.type !== 2) { + this.tokens.push(this.convertToken(next)); + } + return token; + }; + Parser3.prototype.nextRegexToken = function() { + this.collectComments(); + var token = this.scanner.scanRegExp(); + if (this.config.tokens) { + this.tokens.pop(); + this.tokens.push(this.convertToken(token)); + } + this.lookahead = token; + this.nextToken(); + return token; + }; + Parser3.prototype.createNode = function() { + return { + index: this.startMarker.index, + line: this.startMarker.line, + column: this.startMarker.column + }; + }; + Parser3.prototype.startNode = function(token, lastLineStart) { + if (lastLineStart === void 0) { + lastLineStart = 0; + } + var column = token.start - token.lineStart; + var line = token.lineNumber; + if (column < 0) { + column += lastLineStart; + line--; + } + return { + index: token.start, + line, + column + }; + }; + Parser3.prototype.finalize = function(marker, node) { + if (this.config.range) { + node.range = [marker.index, this.lastMarker.index]; + } + if (this.config.loc) { + node.loc = { + start: { + line: marker.line, + column: marker.column + }, + end: { + line: this.lastMarker.line, + column: this.lastMarker.column + } + }; + if (this.config.source) { + node.loc.source = this.config.source; + } + } + if (this.delegate) { + var metadata = { + start: { + line: marker.line, + column: marker.column, + offset: marker.index + }, + end: { + line: this.lastMarker.line, + column: this.lastMarker.column, + offset: this.lastMarker.index + } + }; + this.delegate(node, metadata); + } + return node; + }; + Parser3.prototype.expect = function(value) { + var token = this.nextToken(); + if (token.type !== 7 || token.value !== value) { + this.throwUnexpectedToken(token); + } + }; + Parser3.prototype.expectCommaSeparator = function() { + if (this.config.tolerant) { + var token = this.lookahead; + if (token.type === 7 && token.value === ",") { + this.nextToken(); + } else if (token.type === 7 && token.value === ";") { + this.nextToken(); + this.tolerateUnexpectedToken(token); + } else { + this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken); + } + } else { + this.expect(","); + } + }; + Parser3.prototype.expectKeyword = function(keyword) { + var token = this.nextToken(); + if (token.type !== 4 || token.value !== keyword) { + this.throwUnexpectedToken(token); + } + }; + Parser3.prototype.match = function(value) { + return this.lookahead.type === 7 && this.lookahead.value === value; + }; + Parser3.prototype.matchKeyword = function(keyword) { + return this.lookahead.type === 4 && this.lookahead.value === keyword; + }; + Parser3.prototype.matchContextualKeyword = function(keyword) { + return this.lookahead.type === 3 && this.lookahead.value === keyword; + }; + Parser3.prototype.matchAssign = function() { + if (this.lookahead.type !== 7) { + return false; + } + var op = this.lookahead.value; + return op === "=" || op === "*=" || op === "**=" || op === "/=" || op === "%=" || op === "+=" || op === "-=" || op === "<<=" || op === ">>=" || op === ">>>=" || op === "&=" || op === "^=" || op === "|="; + }; + Parser3.prototype.isolateCoverGrammar = function(parseFunction) { + var previousIsBindingElement = this.context.isBindingElement; + var previousIsAssignmentTarget = this.context.isAssignmentTarget; + var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError; + this.context.isBindingElement = true; + this.context.isAssignmentTarget = true; + this.context.firstCoverInitializedNameError = null; + var result = parseFunction.call(this); + if (this.context.firstCoverInitializedNameError !== null) { + this.throwUnexpectedToken(this.context.firstCoverInitializedNameError); + } + this.context.isBindingElement = previousIsBindingElement; + this.context.isAssignmentTarget = previousIsAssignmentTarget; + this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError; + return result; + }; + Parser3.prototype.inheritCoverGrammar = function(parseFunction) { + var previousIsBindingElement = this.context.isBindingElement; + var previousIsAssignmentTarget = this.context.isAssignmentTarget; + var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError; + this.context.isBindingElement = true; + this.context.isAssignmentTarget = true; + this.context.firstCoverInitializedNameError = null; + var result = parseFunction.call(this); + this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement; + this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget; + this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError; + return result; + }; + Parser3.prototype.consumeSemicolon = function() { + if (this.match(";")) { + this.nextToken(); + } else if (!this.hasLineTerminator) { + if (this.lookahead.type !== 2 && !this.match("}")) { + this.throwUnexpectedToken(this.lookahead); + } + this.lastMarker.index = this.startMarker.index; + this.lastMarker.line = this.startMarker.line; + this.lastMarker.column = this.startMarker.column; + } + }; + Parser3.prototype.parsePrimaryExpression = function() { + var node = this.createNode(); + var expr; + var token, raw; + switch (this.lookahead.type) { + case 3: + if ((this.context.isModule || this.context.await) && this.lookahead.value === "await") { + this.tolerateUnexpectedToken(this.lookahead); + } + expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node2.Identifier(this.nextToken().value)); + break; + case 6: + case 8: + if (this.context.strict && this.lookahead.octal) { + this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral); + } + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + token = this.nextToken(); + raw = this.getTokenRaw(token); + expr = this.finalize(node, new Node2.Literal(token.value, raw)); + break; + case 1: + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + token = this.nextToken(); + raw = this.getTokenRaw(token); + expr = this.finalize(node, new Node2.Literal(token.value === "true", raw)); + break; + case 5: + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + token = this.nextToken(); + raw = this.getTokenRaw(token); + expr = this.finalize(node, new Node2.Literal(null, raw)); + break; + case 10: + expr = this.parseTemplateLiteral(); + break; + case 7: + switch (this.lookahead.value) { + case "(": + this.context.isBindingElement = false; + expr = this.inheritCoverGrammar(this.parseGroupExpression); + break; + case "[": + expr = this.inheritCoverGrammar(this.parseArrayInitializer); + break; + case "{": + expr = this.inheritCoverGrammar(this.parseObjectInitializer); + break; + case "/": + case "/=": + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + this.scanner.index = this.startMarker.index; + token = this.nextRegexToken(); + raw = this.getTokenRaw(token); + expr = this.finalize(node, new Node2.RegexLiteral(token.regex, raw, token.pattern, token.flags)); + break; + default: + expr = this.throwUnexpectedToken(this.nextToken()); + } + break; + case 4: + if (!this.context.strict && this.context.allowYield && this.matchKeyword("yield")) { + expr = this.parseIdentifierName(); + } else if (!this.context.strict && this.matchKeyword("let")) { + expr = this.finalize(node, new Node2.Identifier(this.nextToken().value)); + } else { + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + if (this.matchKeyword("function")) { + expr = this.parseFunctionExpression(); + } else if (this.matchKeyword("this")) { + this.nextToken(); + expr = this.finalize(node, new Node2.ThisExpression()); + } else if (this.matchKeyword("class")) { + expr = this.parseClassExpression(); + } else { + expr = this.throwUnexpectedToken(this.nextToken()); + } + } + break; + default: + expr = this.throwUnexpectedToken(this.nextToken()); + } + return expr; + }; + Parser3.prototype.parseSpreadElement = function() { + var node = this.createNode(); + this.expect("..."); + var arg = this.inheritCoverGrammar(this.parseAssignmentExpression); + return this.finalize(node, new Node2.SpreadElement(arg)); + }; + Parser3.prototype.parseArrayInitializer = function() { + var node = this.createNode(); + var elements = []; + this.expect("["); + while (!this.match("]")) { + if (this.match(",")) { + this.nextToken(); + elements.push(null); + } else if (this.match("...")) { + var element = this.parseSpreadElement(); + if (!this.match("]")) { + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + this.expect(","); + } + elements.push(element); + } else { + elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression)); + if (!this.match("]")) { + this.expect(","); + } + } + } + this.expect("]"); + return this.finalize(node, new Node2.ArrayExpression(elements)); + }; + Parser3.prototype.parsePropertyMethod = function(params) { + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + var previousStrict = this.context.strict; + var previousAllowStrictDirective = this.context.allowStrictDirective; + this.context.allowStrictDirective = params.simple; + var body = this.isolateCoverGrammar(this.parseFunctionSourceElements); + if (this.context.strict && params.firstRestricted) { + this.tolerateUnexpectedToken(params.firstRestricted, params.message); + } + if (this.context.strict && params.stricted) { + this.tolerateUnexpectedToken(params.stricted, params.message); + } + this.context.strict = previousStrict; + this.context.allowStrictDirective = previousAllowStrictDirective; + return body; + }; + Parser3.prototype.parsePropertyMethodFunction = function() { + var isGenerator = false; + var node = this.createNode(); + var previousAllowYield = this.context.allowYield; + this.context.allowYield = true; + var params = this.parseFormalParameters(); + var method = this.parsePropertyMethod(params); + this.context.allowYield = previousAllowYield; + return this.finalize(node, new Node2.FunctionExpression(null, params.params, method, isGenerator)); + }; + Parser3.prototype.parsePropertyMethodAsyncFunction = function() { + var node = this.createNode(); + var previousAllowYield = this.context.allowYield; + var previousAwait = this.context.await; + this.context.allowYield = false; + this.context.await = true; + var params = this.parseFormalParameters(); + var method = this.parsePropertyMethod(params); + this.context.allowYield = previousAllowYield; + this.context.await = previousAwait; + return this.finalize(node, new Node2.AsyncFunctionExpression(null, params.params, method)); + }; + Parser3.prototype.parseObjectPropertyKey = function() { + var node = this.createNode(); + var token = this.nextToken(); + var key; + switch (token.type) { + case 8: + case 6: + if (this.context.strict && token.octal) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral); + } + var raw = this.getTokenRaw(token); + key = this.finalize(node, new Node2.Literal(token.value, raw)); + break; + case 3: + case 1: + case 5: + case 4: + key = this.finalize(node, new Node2.Identifier(token.value)); + break; + case 7: + if (token.value === "[") { + key = this.isolateCoverGrammar(this.parseAssignmentExpression); + this.expect("]"); + } else { + key = this.throwUnexpectedToken(token); + } + break; + default: + key = this.throwUnexpectedToken(token); + } + return key; + }; + Parser3.prototype.isPropertyKey = function(key, value) { + return key.type === syntax_1.Syntax.Identifier && key.name === value || key.type === syntax_1.Syntax.Literal && key.value === value; + }; + Parser3.prototype.parseObjectProperty = function(hasProto) { + var node = this.createNode(); + var token = this.lookahead; + var kind; + var key = null; + var value = null; + var computed = false; + var method = false; + var shorthand = false; + var isAsync = false; + if (token.type === 3) { + var id = token.value; + this.nextToken(); + computed = this.match("["); + isAsync = !this.hasLineTerminator && id === "async" && !this.match(":") && !this.match("(") && !this.match("*") && !this.match(","); + key = isAsync ? this.parseObjectPropertyKey() : this.finalize(node, new Node2.Identifier(id)); + } else if (this.match("*")) { + this.nextToken(); + } else { + computed = this.match("["); + key = this.parseObjectPropertyKey(); + } + var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead); + if (token.type === 3 && !isAsync && token.value === "get" && lookaheadPropertyKey) { + kind = "get"; + computed = this.match("["); + key = this.parseObjectPropertyKey(); + this.context.allowYield = false; + value = this.parseGetterMethod(); + } else if (token.type === 3 && !isAsync && token.value === "set" && lookaheadPropertyKey) { + kind = "set"; + computed = this.match("["); + key = this.parseObjectPropertyKey(); + value = this.parseSetterMethod(); + } else if (token.type === 7 && token.value === "*" && lookaheadPropertyKey) { + kind = "init"; + computed = this.match("["); + key = this.parseObjectPropertyKey(); + value = this.parseGeneratorMethod(); + method = true; + } else { + if (!key) { + this.throwUnexpectedToken(this.lookahead); + } + kind = "init"; + if (this.match(":") && !isAsync) { + if (!computed && this.isPropertyKey(key, "__proto__")) { + if (hasProto.value) { + this.tolerateError(messages_1.Messages.DuplicateProtoProperty); + } + hasProto.value = true; + } + this.nextToken(); + value = this.inheritCoverGrammar(this.parseAssignmentExpression); + } else if (this.match("(")) { + value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction(); + method = true; + } else if (token.type === 3) { + var id = this.finalize(node, new Node2.Identifier(token.value)); + if (this.match("=")) { + this.context.firstCoverInitializedNameError = this.lookahead; + this.nextToken(); + shorthand = true; + var init = this.isolateCoverGrammar(this.parseAssignmentExpression); + value = this.finalize(node, new Node2.AssignmentPattern(id, init)); + } else { + shorthand = true; + value = id; + } + } else { + this.throwUnexpectedToken(this.nextToken()); + } + } + return this.finalize(node, new Node2.Property(kind, key, computed, value, method, shorthand)); + }; + Parser3.prototype.parseObjectInitializer = function() { + var node = this.createNode(); + this.expect("{"); + var properties = []; + var hasProto = { value: false }; + while (!this.match("}")) { + properties.push(this.parseObjectProperty(hasProto)); + if (!this.match("}")) { + this.expectCommaSeparator(); + } + } + this.expect("}"); + return this.finalize(node, new Node2.ObjectExpression(properties)); + }; + Parser3.prototype.parseTemplateHead = function() { + assert_1.assert(this.lookahead.head, "Template literal must start with a template head"); + var node = this.createNode(); + var token = this.nextToken(); + var raw = token.value; + var cooked = token.cooked; + return this.finalize(node, new Node2.TemplateElement({ raw, cooked }, token.tail)); + }; + Parser3.prototype.parseTemplateElement = function() { + if (this.lookahead.type !== 10) { + this.throwUnexpectedToken(); + } + var node = this.createNode(); + var token = this.nextToken(); + var raw = token.value; + var cooked = token.cooked; + return this.finalize(node, new Node2.TemplateElement({ raw, cooked }, token.tail)); + }; + Parser3.prototype.parseTemplateLiteral = function() { + var node = this.createNode(); + var expressions = []; + var quasis = []; + var quasi = this.parseTemplateHead(); + quasis.push(quasi); + while (!quasi.tail) { + expressions.push(this.parseExpression()); + quasi = this.parseTemplateElement(); + quasis.push(quasi); + } + return this.finalize(node, new Node2.TemplateLiteral(quasis, expressions)); + }; + Parser3.prototype.reinterpretExpressionAsPattern = function(expr) { + switch (expr.type) { + case syntax_1.Syntax.Identifier: + case syntax_1.Syntax.MemberExpression: + case syntax_1.Syntax.RestElement: + case syntax_1.Syntax.AssignmentPattern: + break; + case syntax_1.Syntax.SpreadElement: + expr.type = syntax_1.Syntax.RestElement; + this.reinterpretExpressionAsPattern(expr.argument); + break; + case syntax_1.Syntax.ArrayExpression: + expr.type = syntax_1.Syntax.ArrayPattern; + for (var i = 0; i < expr.elements.length; i++) { + if (expr.elements[i] !== null) { + this.reinterpretExpressionAsPattern(expr.elements[i]); + } + } + break; + case syntax_1.Syntax.ObjectExpression: + expr.type = syntax_1.Syntax.ObjectPattern; + for (var i = 0; i < expr.properties.length; i++) { + this.reinterpretExpressionAsPattern(expr.properties[i].value); + } + break; + case syntax_1.Syntax.AssignmentExpression: + expr.type = syntax_1.Syntax.AssignmentPattern; + delete expr.operator; + this.reinterpretExpressionAsPattern(expr.left); + break; + default: + break; + } + }; + Parser3.prototype.parseGroupExpression = function() { + var expr; + this.expect("("); + if (this.match(")")) { + this.nextToken(); + if (!this.match("=>")) { + this.expect("=>"); + } + expr = { + type: ArrowParameterPlaceHolder, + params: [], + async: false + }; + } else { + var startToken = this.lookahead; + var params = []; + if (this.match("...")) { + expr = this.parseRestElement(params); + this.expect(")"); + if (!this.match("=>")) { + this.expect("=>"); + } + expr = { + type: ArrowParameterPlaceHolder, + params: [expr], + async: false + }; + } else { + var arrow = false; + this.context.isBindingElement = true; + expr = this.inheritCoverGrammar(this.parseAssignmentExpression); + if (this.match(",")) { + var expressions = []; + this.context.isAssignmentTarget = false; + expressions.push(expr); + while (this.lookahead.type !== 2) { + if (!this.match(",")) { + break; + } + this.nextToken(); + if (this.match(")")) { + this.nextToken(); + for (var i = 0; i < expressions.length; i++) { + this.reinterpretExpressionAsPattern(expressions[i]); + } + arrow = true; + expr = { + type: ArrowParameterPlaceHolder, + params: expressions, + async: false + }; + } else if (this.match("...")) { + if (!this.context.isBindingElement) { + this.throwUnexpectedToken(this.lookahead); + } + expressions.push(this.parseRestElement(params)); + this.expect(")"); + if (!this.match("=>")) { + this.expect("=>"); + } + this.context.isBindingElement = false; + for (var i = 0; i < expressions.length; i++) { + this.reinterpretExpressionAsPattern(expressions[i]); + } + arrow = true; + expr = { + type: ArrowParameterPlaceHolder, + params: expressions, + async: false + }; + } else { + expressions.push(this.inheritCoverGrammar(this.parseAssignmentExpression)); + } + if (arrow) { + break; + } + } + if (!arrow) { + expr = this.finalize(this.startNode(startToken), new Node2.SequenceExpression(expressions)); + } + } + if (!arrow) { + this.expect(")"); + if (this.match("=>")) { + if (expr.type === syntax_1.Syntax.Identifier && expr.name === "yield") { + arrow = true; + expr = { + type: ArrowParameterPlaceHolder, + params: [expr], + async: false + }; + } + if (!arrow) { + if (!this.context.isBindingElement) { + this.throwUnexpectedToken(this.lookahead); + } + if (expr.type === syntax_1.Syntax.SequenceExpression) { + for (var i = 0; i < expr.expressions.length; i++) { + this.reinterpretExpressionAsPattern(expr.expressions[i]); + } + } else { + this.reinterpretExpressionAsPattern(expr); + } + var parameters = expr.type === syntax_1.Syntax.SequenceExpression ? expr.expressions : [expr]; + expr = { + type: ArrowParameterPlaceHolder, + params: parameters, + async: false + }; + } + } + this.context.isBindingElement = false; + } + } + } + return expr; + }; + Parser3.prototype.parseArguments = function() { + this.expect("("); + var args = []; + if (!this.match(")")) { + while (true) { + var expr = this.match("...") ? this.parseSpreadElement() : this.isolateCoverGrammar(this.parseAssignmentExpression); + args.push(expr); + if (this.match(")")) { + break; + } + this.expectCommaSeparator(); + if (this.match(")")) { + break; + } + } + } + this.expect(")"); + return args; + }; + Parser3.prototype.isIdentifierName = function(token) { + return token.type === 3 || token.type === 4 || token.type === 1 || token.type === 5; + }; + Parser3.prototype.parseIdentifierName = function() { + var node = this.createNode(); + var token = this.nextToken(); + if (!this.isIdentifierName(token)) { + this.throwUnexpectedToken(token); + } + return this.finalize(node, new Node2.Identifier(token.value)); + }; + Parser3.prototype.parseNewExpression = function() { + var node = this.createNode(); + var id = this.parseIdentifierName(); + assert_1.assert(id.name === "new", "New expression must start with `new`"); + var expr; + if (this.match(".")) { + this.nextToken(); + if (this.lookahead.type === 3 && this.context.inFunctionBody && this.lookahead.value === "target") { + var property = this.parseIdentifierName(); + expr = new Node2.MetaProperty(id, property); + } else { + this.throwUnexpectedToken(this.lookahead); + } + } else { + var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression); + var args = this.match("(") ? this.parseArguments() : []; + expr = new Node2.NewExpression(callee, args); + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + } + return this.finalize(node, expr); + }; + Parser3.prototype.parseAsyncArgument = function() { + var arg = this.parseAssignmentExpression(); + this.context.firstCoverInitializedNameError = null; + return arg; + }; + Parser3.prototype.parseAsyncArguments = function() { + this.expect("("); + var args = []; + if (!this.match(")")) { + while (true) { + var expr = this.match("...") ? this.parseSpreadElement() : this.isolateCoverGrammar(this.parseAsyncArgument); + args.push(expr); + if (this.match(")")) { + break; + } + this.expectCommaSeparator(); + if (this.match(")")) { + break; + } + } + } + this.expect(")"); + return args; + }; + Parser3.prototype.parseLeftHandSideExpressionAllowCall = function() { + var startToken = this.lookahead; + var maybeAsync = this.matchContextualKeyword("async"); + var previousAllowIn = this.context.allowIn; + this.context.allowIn = true; + var expr; + if (this.matchKeyword("super") && this.context.inFunctionBody) { + expr = this.createNode(); + this.nextToken(); + expr = this.finalize(expr, new Node2.Super()); + if (!this.match("(") && !this.match(".") && !this.match("[")) { + this.throwUnexpectedToken(this.lookahead); + } + } else { + expr = this.inheritCoverGrammar(this.matchKeyword("new") ? this.parseNewExpression : this.parsePrimaryExpression); + } + while (true) { + if (this.match(".")) { + this.context.isBindingElement = false; + this.context.isAssignmentTarget = true; + this.expect("."); + var property = this.parseIdentifierName(); + expr = this.finalize(this.startNode(startToken), new Node2.StaticMemberExpression(expr, property)); + } else if (this.match("(")) { + var asyncArrow = maybeAsync && startToken.lineNumber === this.lookahead.lineNumber; + this.context.isBindingElement = false; + this.context.isAssignmentTarget = false; + var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments(); + expr = this.finalize(this.startNode(startToken), new Node2.CallExpression(expr, args)); + if (asyncArrow && this.match("=>")) { + for (var i = 0; i < args.length; ++i) { + this.reinterpretExpressionAsPattern(args[i]); + } + expr = { + type: ArrowParameterPlaceHolder, + params: args, + async: true + }; + } + } else if (this.match("[")) { + this.context.isBindingElement = false; + this.context.isAssignmentTarget = true; + this.expect("["); + var property = this.isolateCoverGrammar(this.parseExpression); + this.expect("]"); + expr = this.finalize(this.startNode(startToken), new Node2.ComputedMemberExpression(expr, property)); + } else if (this.lookahead.type === 10 && this.lookahead.head) { + var quasi = this.parseTemplateLiteral(); + expr = this.finalize(this.startNode(startToken), new Node2.TaggedTemplateExpression(expr, quasi)); + } else { + break; + } + } + this.context.allowIn = previousAllowIn; + return expr; + }; + Parser3.prototype.parseSuper = function() { + var node = this.createNode(); + this.expectKeyword("super"); + if (!this.match("[") && !this.match(".")) { + this.throwUnexpectedToken(this.lookahead); + } + return this.finalize(node, new Node2.Super()); + }; + Parser3.prototype.parseLeftHandSideExpression = function() { + assert_1.assert(this.context.allowIn, "callee of new expression always allow in keyword."); + var node = this.startNode(this.lookahead); + var expr = this.matchKeyword("super") && this.context.inFunctionBody ? this.parseSuper() : this.inheritCoverGrammar(this.matchKeyword("new") ? this.parseNewExpression : this.parsePrimaryExpression); + while (true) { + if (this.match("[")) { + this.context.isBindingElement = false; + this.context.isAssignmentTarget = true; + this.expect("["); + var property = this.isolateCoverGrammar(this.parseExpression); + this.expect("]"); + expr = this.finalize(node, new Node2.ComputedMemberExpression(expr, property)); + } else if (this.match(".")) { + this.context.isBindingElement = false; + this.context.isAssignmentTarget = true; + this.expect("."); + var property = this.parseIdentifierName(); + expr = this.finalize(node, new Node2.StaticMemberExpression(expr, property)); + } else if (this.lookahead.type === 10 && this.lookahead.head) { + var quasi = this.parseTemplateLiteral(); + expr = this.finalize(node, new Node2.TaggedTemplateExpression(expr, quasi)); + } else { + break; + } + } + return expr; + }; + Parser3.prototype.parseUpdateExpression = function() { + var expr; + var startToken = this.lookahead; + if (this.match("++") || this.match("--")) { + var node = this.startNode(startToken); + var token = this.nextToken(); + expr = this.inheritCoverGrammar(this.parseUnaryExpression); + if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) { + this.tolerateError(messages_1.Messages.StrictLHSPrefix); + } + if (!this.context.isAssignmentTarget) { + this.tolerateError(messages_1.Messages.InvalidLHSInAssignment); + } + var prefix = true; + expr = this.finalize(node, new Node2.UpdateExpression(token.value, expr, prefix)); + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + } else { + expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall); + if (!this.hasLineTerminator && this.lookahead.type === 7) { + if (this.match("++") || this.match("--")) { + if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) { + this.tolerateError(messages_1.Messages.StrictLHSPostfix); + } + if (!this.context.isAssignmentTarget) { + this.tolerateError(messages_1.Messages.InvalidLHSInAssignment); + } + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + var operator = this.nextToken().value; + var prefix = false; + expr = this.finalize(this.startNode(startToken), new Node2.UpdateExpression(operator, expr, prefix)); + } + } + } + return expr; + }; + Parser3.prototype.parseAwaitExpression = function() { + var node = this.createNode(); + this.nextToken(); + var argument = this.parseUnaryExpression(); + return this.finalize(node, new Node2.AwaitExpression(argument)); + }; + Parser3.prototype.parseUnaryExpression = function() { + var expr; + if (this.match("+") || this.match("-") || this.match("~") || this.match("!") || this.matchKeyword("delete") || this.matchKeyword("void") || this.matchKeyword("typeof")) { + var node = this.startNode(this.lookahead); + var token = this.nextToken(); + expr = this.inheritCoverGrammar(this.parseUnaryExpression); + expr = this.finalize(node, new Node2.UnaryExpression(token.value, expr)); + if (this.context.strict && expr.operator === "delete" && expr.argument.type === syntax_1.Syntax.Identifier) { + this.tolerateError(messages_1.Messages.StrictDelete); + } + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + } else if (this.context.await && this.matchContextualKeyword("await")) { + expr = this.parseAwaitExpression(); + } else { + expr = this.parseUpdateExpression(); + } + return expr; + }; + Parser3.prototype.parseExponentiationExpression = function() { + var startToken = this.lookahead; + var expr = this.inheritCoverGrammar(this.parseUnaryExpression); + if (expr.type !== syntax_1.Syntax.UnaryExpression && this.match("**")) { + this.nextToken(); + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + var left2 = expr; + var right2 = this.isolateCoverGrammar(this.parseExponentiationExpression); + expr = this.finalize(this.startNode(startToken), new Node2.BinaryExpression("**", left2, right2)); + } + return expr; + }; + Parser3.prototype.binaryPrecedence = function(token) { + var op = token.value; + var precedence; + if (token.type === 7) { + precedence = this.operatorPrecedence[op] || 0; + } else if (token.type === 4) { + precedence = op === "instanceof" || this.context.allowIn && op === "in" ? 7 : 0; + } else { + precedence = 0; + } + return precedence; + }; + Parser3.prototype.parseBinaryExpression = function() { + var startToken = this.lookahead; + var expr = this.inheritCoverGrammar(this.parseExponentiationExpression); + var token = this.lookahead; + var prec = this.binaryPrecedence(token); + if (prec > 0) { + this.nextToken(); + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + var markers = [startToken, this.lookahead]; + var left2 = expr; + var right2 = this.isolateCoverGrammar(this.parseExponentiationExpression); + var stack = [left2, token.value, right2]; + var precedences = [prec]; + while (true) { + prec = this.binaryPrecedence(this.lookahead); + if (prec <= 0) { + break; + } + while (stack.length > 2 && prec <= precedences[precedences.length - 1]) { + right2 = stack.pop(); + var operator = stack.pop(); + precedences.pop(); + left2 = stack.pop(); + markers.pop(); + var node = this.startNode(markers[markers.length - 1]); + stack.push(this.finalize(node, new Node2.BinaryExpression(operator, left2, right2))); + } + stack.push(this.nextToken().value); + precedences.push(prec); + markers.push(this.lookahead); + stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression)); + } + var i = stack.length - 1; + expr = stack[i]; + var lastMarker = markers.pop(); + while (i > 1) { + var marker = markers.pop(); + var lastLineStart = lastMarker && lastMarker.lineStart; + var node = this.startNode(marker, lastLineStart); + var operator = stack[i - 1]; + expr = this.finalize(node, new Node2.BinaryExpression(operator, stack[i - 2], expr)); + i -= 2; + lastMarker = marker; + } + } + return expr; + }; + Parser3.prototype.parseConditionalExpression = function() { + var startToken = this.lookahead; + var expr = this.inheritCoverGrammar(this.parseBinaryExpression); + if (this.match("?")) { + this.nextToken(); + var previousAllowIn = this.context.allowIn; + this.context.allowIn = true; + var consequent = this.isolateCoverGrammar(this.parseAssignmentExpression); + this.context.allowIn = previousAllowIn; + this.expect(":"); + var alternate = this.isolateCoverGrammar(this.parseAssignmentExpression); + expr = this.finalize(this.startNode(startToken), new Node2.ConditionalExpression(expr, consequent, alternate)); + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + } + return expr; + }; + Parser3.prototype.checkPatternParam = function(options, param) { + switch (param.type) { + case syntax_1.Syntax.Identifier: + this.validateParam(options, param, param.name); + break; + case syntax_1.Syntax.RestElement: + this.checkPatternParam(options, param.argument); + break; + case syntax_1.Syntax.AssignmentPattern: + this.checkPatternParam(options, param.left); + break; + case syntax_1.Syntax.ArrayPattern: + for (var i = 0; i < param.elements.length; i++) { + if (param.elements[i] !== null) { + this.checkPatternParam(options, param.elements[i]); + } + } + break; + case syntax_1.Syntax.ObjectPattern: + for (var i = 0; i < param.properties.length; i++) { + this.checkPatternParam(options, param.properties[i].value); + } + break; + default: + break; + } + options.simple = options.simple && param instanceof Node2.Identifier; + }; + Parser3.prototype.reinterpretAsCoverFormalsList = function(expr) { + var params = [expr]; + var options; + var asyncArrow = false; + switch (expr.type) { + case syntax_1.Syntax.Identifier: + break; + case ArrowParameterPlaceHolder: + params = expr.params; + asyncArrow = expr.async; + break; + default: + return null; + } + options = { + simple: true, + paramSet: {} + }; + for (var i = 0; i < params.length; ++i) { + var param = params[i]; + if (param.type === syntax_1.Syntax.AssignmentPattern) { + if (param.right.type === syntax_1.Syntax.YieldExpression) { + if (param.right.argument) { + this.throwUnexpectedToken(this.lookahead); + } + param.right.type = syntax_1.Syntax.Identifier; + param.right.name = "yield"; + delete param.right.argument; + delete param.right.delegate; + } + } else if (asyncArrow && param.type === syntax_1.Syntax.Identifier && param.name === "await") { + this.throwUnexpectedToken(this.lookahead); + } + this.checkPatternParam(options, param); + params[i] = param; + } + if (this.context.strict || !this.context.allowYield) { + for (var i = 0; i < params.length; ++i) { + var param = params[i]; + if (param.type === syntax_1.Syntax.YieldExpression) { + this.throwUnexpectedToken(this.lookahead); + } + } + } + if (options.message === messages_1.Messages.StrictParamDupe) { + var token = this.context.strict ? options.stricted : options.firstRestricted; + this.throwUnexpectedToken(token, options.message); + } + return { + simple: options.simple, + params, + stricted: options.stricted, + firstRestricted: options.firstRestricted, + message: options.message + }; + }; + Parser3.prototype.parseAssignmentExpression = function() { + var expr; + if (!this.context.allowYield && this.matchKeyword("yield")) { + expr = this.parseYieldExpression(); + } else { + var startToken = this.lookahead; + var token = startToken; + expr = this.parseConditionalExpression(); + if (token.type === 3 && token.lineNumber === this.lookahead.lineNumber && token.value === "async") { + if (this.lookahead.type === 3 || this.matchKeyword("yield")) { + var arg = this.parsePrimaryExpression(); + this.reinterpretExpressionAsPattern(arg); + expr = { + type: ArrowParameterPlaceHolder, + params: [arg], + async: true + }; + } + } + if (expr.type === ArrowParameterPlaceHolder || this.match("=>")) { + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + var isAsync = expr.async; + var list = this.reinterpretAsCoverFormalsList(expr); + if (list) { + if (this.hasLineTerminator) { + this.tolerateUnexpectedToken(this.lookahead); + } + this.context.firstCoverInitializedNameError = null; + var previousStrict = this.context.strict; + var previousAllowStrictDirective = this.context.allowStrictDirective; + this.context.allowStrictDirective = list.simple; + var previousAllowYield = this.context.allowYield; + var previousAwait = this.context.await; + this.context.allowYield = true; + this.context.await = isAsync; + var node = this.startNode(startToken); + this.expect("=>"); + var body = void 0; + if (this.match("{")) { + var previousAllowIn = this.context.allowIn; + this.context.allowIn = true; + body = this.parseFunctionSourceElements(); + this.context.allowIn = previousAllowIn; + } else { + body = this.isolateCoverGrammar(this.parseAssignmentExpression); + } + var expression = body.type !== syntax_1.Syntax.BlockStatement; + if (this.context.strict && list.firstRestricted) { + this.throwUnexpectedToken(list.firstRestricted, list.message); + } + if (this.context.strict && list.stricted) { + this.tolerateUnexpectedToken(list.stricted, list.message); + } + expr = isAsync ? this.finalize(node, new Node2.AsyncArrowFunctionExpression(list.params, body, expression)) : this.finalize(node, new Node2.ArrowFunctionExpression(list.params, body, expression)); + this.context.strict = previousStrict; + this.context.allowStrictDirective = previousAllowStrictDirective; + this.context.allowYield = previousAllowYield; + this.context.await = previousAwait; + } + } else { + if (this.matchAssign()) { + if (!this.context.isAssignmentTarget) { + this.tolerateError(messages_1.Messages.InvalidLHSInAssignment); + } + if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) { + var id = expr; + if (this.scanner.isRestrictedWord(id.name)) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment); + } + if (this.scanner.isStrictModeReservedWord(id.name)) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord); + } + } + if (!this.match("=")) { + this.context.isAssignmentTarget = false; + this.context.isBindingElement = false; + } else { + this.reinterpretExpressionAsPattern(expr); + } + token = this.nextToken(); + var operator = token.value; + var right2 = this.isolateCoverGrammar(this.parseAssignmentExpression); + expr = this.finalize(this.startNode(startToken), new Node2.AssignmentExpression(operator, expr, right2)); + this.context.firstCoverInitializedNameError = null; + } + } + } + return expr; + }; + Parser3.prototype.parseExpression = function() { + var startToken = this.lookahead; + var expr = this.isolateCoverGrammar(this.parseAssignmentExpression); + if (this.match(",")) { + var expressions = []; + expressions.push(expr); + while (this.lookahead.type !== 2) { + if (!this.match(",")) { + break; + } + this.nextToken(); + expressions.push(this.isolateCoverGrammar(this.parseAssignmentExpression)); + } + expr = this.finalize(this.startNode(startToken), new Node2.SequenceExpression(expressions)); + } + return expr; + }; + Parser3.prototype.parseStatementListItem = function() { + var statement; + this.context.isAssignmentTarget = true; + this.context.isBindingElement = true; + if (this.lookahead.type === 4) { + switch (this.lookahead.value) { + case "export": + if (!this.context.isModule) { + this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalExportDeclaration); + } + statement = this.parseExportDeclaration(); + break; + case "import": + if (!this.context.isModule) { + this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration); + } + statement = this.parseImportDeclaration(); + break; + case "const": + statement = this.parseLexicalDeclaration({ inFor: false }); + break; + case "function": + statement = this.parseFunctionDeclaration(); + break; + case "class": + statement = this.parseClassDeclaration(); + break; + case "let": + statement = this.isLexicalDeclaration() ? this.parseLexicalDeclaration({ inFor: false }) : this.parseStatement(); + break; + default: + statement = this.parseStatement(); + break; + } + } else { + statement = this.parseStatement(); + } + return statement; + }; + Parser3.prototype.parseBlock = function() { + var node = this.createNode(); + this.expect("{"); + var block = []; + while (true) { + if (this.match("}")) { + break; + } + block.push(this.parseStatementListItem()); + } + this.expect("}"); + return this.finalize(node, new Node2.BlockStatement(block)); + }; + Parser3.prototype.parseLexicalBinding = function(kind, options) { + var node = this.createNode(); + var params = []; + var id = this.parsePattern(params, kind); + if (this.context.strict && id.type === syntax_1.Syntax.Identifier) { + if (this.scanner.isRestrictedWord(id.name)) { + this.tolerateError(messages_1.Messages.StrictVarName); + } + } + var init = null; + if (kind === "const") { + if (!this.matchKeyword("in") && !this.matchContextualKeyword("of")) { + if (this.match("=")) { + this.nextToken(); + init = this.isolateCoverGrammar(this.parseAssignmentExpression); + } else { + this.throwError(messages_1.Messages.DeclarationMissingInitializer, "const"); + } + } + } else if (!options.inFor && id.type !== syntax_1.Syntax.Identifier || this.match("=")) { + this.expect("="); + init = this.isolateCoverGrammar(this.parseAssignmentExpression); + } + return this.finalize(node, new Node2.VariableDeclarator(id, init)); + }; + Parser3.prototype.parseBindingList = function(kind, options) { + var list = [this.parseLexicalBinding(kind, options)]; + while (this.match(",")) { + this.nextToken(); + list.push(this.parseLexicalBinding(kind, options)); + } + return list; + }; + Parser3.prototype.isLexicalDeclaration = function() { + var state = this.scanner.saveState(); + this.scanner.scanComments(); + var next = this.scanner.lex(); + this.scanner.restoreState(state); + return next.type === 3 || next.type === 7 && next.value === "[" || next.type === 7 && next.value === "{" || next.type === 4 && next.value === "let" || next.type === 4 && next.value === "yield"; + }; + Parser3.prototype.parseLexicalDeclaration = function(options) { + var node = this.createNode(); + var kind = this.nextToken().value; + assert_1.assert(kind === "let" || kind === "const", "Lexical declaration must be either let or const"); + var declarations = this.parseBindingList(kind, options); + this.consumeSemicolon(); + return this.finalize(node, new Node2.VariableDeclaration(declarations, kind)); + }; + Parser3.prototype.parseBindingRestElement = function(params, kind) { + var node = this.createNode(); + this.expect("..."); + var arg = this.parsePattern(params, kind); + return this.finalize(node, new Node2.RestElement(arg)); + }; + Parser3.prototype.parseArrayPattern = function(params, kind) { + var node = this.createNode(); + this.expect("["); + var elements = []; + while (!this.match("]")) { + if (this.match(",")) { + this.nextToken(); + elements.push(null); + } else { + if (this.match("...")) { + elements.push(this.parseBindingRestElement(params, kind)); + break; + } else { + elements.push(this.parsePatternWithDefault(params, kind)); + } + if (!this.match("]")) { + this.expect(","); + } + } + } + this.expect("]"); + return this.finalize(node, new Node2.ArrayPattern(elements)); + }; + Parser3.prototype.parsePropertyPattern = function(params, kind) { + var node = this.createNode(); + var computed = false; + var shorthand = false; + var method = false; + var key; + var value; + if (this.lookahead.type === 3) { + var keyToken = this.lookahead; + key = this.parseVariableIdentifier(); + var init = this.finalize(node, new Node2.Identifier(keyToken.value)); + if (this.match("=")) { + params.push(keyToken); + shorthand = true; + this.nextToken(); + var expr = this.parseAssignmentExpression(); + value = this.finalize(this.startNode(keyToken), new Node2.AssignmentPattern(init, expr)); + } else if (!this.match(":")) { + params.push(keyToken); + shorthand = true; + value = init; + } else { + this.expect(":"); + value = this.parsePatternWithDefault(params, kind); + } + } else { + computed = this.match("["); + key = this.parseObjectPropertyKey(); + this.expect(":"); + value = this.parsePatternWithDefault(params, kind); + } + return this.finalize(node, new Node2.Property("init", key, computed, value, method, shorthand)); + }; + Parser3.prototype.parseObjectPattern = function(params, kind) { + var node = this.createNode(); + var properties = []; + this.expect("{"); + while (!this.match("}")) { + properties.push(this.parsePropertyPattern(params, kind)); + if (!this.match("}")) { + this.expect(","); + } + } + this.expect("}"); + return this.finalize(node, new Node2.ObjectPattern(properties)); + }; + Parser3.prototype.parsePattern = function(params, kind) { + var pattern; + if (this.match("[")) { + pattern = this.parseArrayPattern(params, kind); + } else if (this.match("{")) { + pattern = this.parseObjectPattern(params, kind); + } else { + if (this.matchKeyword("let") && (kind === "const" || kind === "let")) { + this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.LetInLexicalBinding); + } + params.push(this.lookahead); + pattern = this.parseVariableIdentifier(kind); + } + return pattern; + }; + Parser3.prototype.parsePatternWithDefault = function(params, kind) { + var startToken = this.lookahead; + var pattern = this.parsePattern(params, kind); + if (this.match("=")) { + this.nextToken(); + var previousAllowYield = this.context.allowYield; + this.context.allowYield = true; + var right2 = this.isolateCoverGrammar(this.parseAssignmentExpression); + this.context.allowYield = previousAllowYield; + pattern = this.finalize(this.startNode(startToken), new Node2.AssignmentPattern(pattern, right2)); + } + return pattern; + }; + Parser3.prototype.parseVariableIdentifier = function(kind) { + var node = this.createNode(); + var token = this.nextToken(); + if (token.type === 4 && token.value === "yield") { + if (this.context.strict) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord); + } else if (!this.context.allowYield) { + this.throwUnexpectedToken(token); + } + } else if (token.type !== 3) { + if (this.context.strict && token.type === 4 && this.scanner.isStrictModeReservedWord(token.value)) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord); + } else { + if (this.context.strict || token.value !== "let" || kind !== "var") { + this.throwUnexpectedToken(token); + } + } + } else if ((this.context.isModule || this.context.await) && token.type === 3 && token.value === "await") { + this.tolerateUnexpectedToken(token); + } + return this.finalize(node, new Node2.Identifier(token.value)); + }; + Parser3.prototype.parseVariableDeclaration = function(options) { + var node = this.createNode(); + var params = []; + var id = this.parsePattern(params, "var"); + if (this.context.strict && id.type === syntax_1.Syntax.Identifier) { + if (this.scanner.isRestrictedWord(id.name)) { + this.tolerateError(messages_1.Messages.StrictVarName); + } + } + var init = null; + if (this.match("=")) { + this.nextToken(); + init = this.isolateCoverGrammar(this.parseAssignmentExpression); + } else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) { + this.expect("="); + } + return this.finalize(node, new Node2.VariableDeclarator(id, init)); + }; + Parser3.prototype.parseVariableDeclarationList = function(options) { + var opt = { inFor: options.inFor }; + var list = []; + list.push(this.parseVariableDeclaration(opt)); + while (this.match(",")) { + this.nextToken(); + list.push(this.parseVariableDeclaration(opt)); + } + return list; + }; + Parser3.prototype.parseVariableStatement = function() { + var node = this.createNode(); + this.expectKeyword("var"); + var declarations = this.parseVariableDeclarationList({ inFor: false }); + this.consumeSemicolon(); + return this.finalize(node, new Node2.VariableDeclaration(declarations, "var")); + }; + Parser3.prototype.parseEmptyStatement = function() { + var node = this.createNode(); + this.expect(";"); + return this.finalize(node, new Node2.EmptyStatement()); + }; + Parser3.prototype.parseExpressionStatement = function() { + var node = this.createNode(); + var expr = this.parseExpression(); + this.consumeSemicolon(); + return this.finalize(node, new Node2.ExpressionStatement(expr)); + }; + Parser3.prototype.parseIfClause = function() { + if (this.context.strict && this.matchKeyword("function")) { + this.tolerateError(messages_1.Messages.StrictFunction); + } + return this.parseStatement(); + }; + Parser3.prototype.parseIfStatement = function() { + var node = this.createNode(); + var consequent; + var alternate = null; + this.expectKeyword("if"); + this.expect("("); + var test = this.parseExpression(); + if (!this.match(")") && this.config.tolerant) { + this.tolerateUnexpectedToken(this.nextToken()); + consequent = this.finalize(this.createNode(), new Node2.EmptyStatement()); + } else { + this.expect(")"); + consequent = this.parseIfClause(); + if (this.matchKeyword("else")) { + this.nextToken(); + alternate = this.parseIfClause(); + } + } + return this.finalize(node, new Node2.IfStatement(test, consequent, alternate)); + }; + Parser3.prototype.parseDoWhileStatement = function() { + var node = this.createNode(); + this.expectKeyword("do"); + var previousInIteration = this.context.inIteration; + this.context.inIteration = true; + var body = this.parseStatement(); + this.context.inIteration = previousInIteration; + this.expectKeyword("while"); + this.expect("("); + var test = this.parseExpression(); + if (!this.match(")") && this.config.tolerant) { + this.tolerateUnexpectedToken(this.nextToken()); + } else { + this.expect(")"); + if (this.match(";")) { + this.nextToken(); + } + } + return this.finalize(node, new Node2.DoWhileStatement(body, test)); + }; + Parser3.prototype.parseWhileStatement = function() { + var node = this.createNode(); + var body; + this.expectKeyword("while"); + this.expect("("); + var test = this.parseExpression(); + if (!this.match(")") && this.config.tolerant) { + this.tolerateUnexpectedToken(this.nextToken()); + body = this.finalize(this.createNode(), new Node2.EmptyStatement()); + } else { + this.expect(")"); + var previousInIteration = this.context.inIteration; + this.context.inIteration = true; + body = this.parseStatement(); + this.context.inIteration = previousInIteration; + } + return this.finalize(node, new Node2.WhileStatement(test, body)); + }; + Parser3.prototype.parseForStatement = function() { + var init = null; + var test = null; + var update = null; + var forIn = true; + var left2, right2; + var node = this.createNode(); + this.expectKeyword("for"); + this.expect("("); + if (this.match(";")) { + this.nextToken(); + } else { + if (this.matchKeyword("var")) { + init = this.createNode(); + this.nextToken(); + var previousAllowIn = this.context.allowIn; + this.context.allowIn = false; + var declarations = this.parseVariableDeclarationList({ inFor: true }); + this.context.allowIn = previousAllowIn; + if (declarations.length === 1 && this.matchKeyword("in")) { + var decl = declarations[0]; + if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) { + this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, "for-in"); + } + init = this.finalize(init, new Node2.VariableDeclaration(declarations, "var")); + this.nextToken(); + left2 = init; + right2 = this.parseExpression(); + init = null; + } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) { + init = this.finalize(init, new Node2.VariableDeclaration(declarations, "var")); + this.nextToken(); + left2 = init; + right2 = this.parseAssignmentExpression(); + init = null; + forIn = false; + } else { + init = this.finalize(init, new Node2.VariableDeclaration(declarations, "var")); + this.expect(";"); + } + } else if (this.matchKeyword("const") || this.matchKeyword("let")) { + init = this.createNode(); + var kind = this.nextToken().value; + if (!this.context.strict && this.lookahead.value === "in") { + init = this.finalize(init, new Node2.Identifier(kind)); + this.nextToken(); + left2 = init; + right2 = this.parseExpression(); + init = null; + } else { + var previousAllowIn = this.context.allowIn; + this.context.allowIn = false; + var declarations = this.parseBindingList(kind, { inFor: true }); + this.context.allowIn = previousAllowIn; + if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword("in")) { + init = this.finalize(init, new Node2.VariableDeclaration(declarations, kind)); + this.nextToken(); + left2 = init; + right2 = this.parseExpression(); + init = null; + } else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword("of")) { + init = this.finalize(init, new Node2.VariableDeclaration(declarations, kind)); + this.nextToken(); + left2 = init; + right2 = this.parseAssignmentExpression(); + init = null; + forIn = false; + } else { + this.consumeSemicolon(); + init = this.finalize(init, new Node2.VariableDeclaration(declarations, kind)); + } + } + } else { + var initStartToken = this.lookahead; + var previousAllowIn = this.context.allowIn; + this.context.allowIn = false; + init = this.inheritCoverGrammar(this.parseAssignmentExpression); + this.context.allowIn = previousAllowIn; + if (this.matchKeyword("in")) { + if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) { + this.tolerateError(messages_1.Messages.InvalidLHSInForIn); + } + this.nextToken(); + this.reinterpretExpressionAsPattern(init); + left2 = init; + right2 = this.parseExpression(); + init = null; + } else if (this.matchContextualKeyword("of")) { + if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) { + this.tolerateError(messages_1.Messages.InvalidLHSInForLoop); + } + this.nextToken(); + this.reinterpretExpressionAsPattern(init); + left2 = init; + right2 = this.parseAssignmentExpression(); + init = null; + forIn = false; + } else { + if (this.match(",")) { + var initSeq = [init]; + while (this.match(",")) { + this.nextToken(); + initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression)); + } + init = this.finalize(this.startNode(initStartToken), new Node2.SequenceExpression(initSeq)); + } + this.expect(";"); + } + } + } + if (typeof left2 === "undefined") { + if (!this.match(";")) { + test = this.parseExpression(); + } + this.expect(";"); + if (!this.match(")")) { + update = this.parseExpression(); + } + } + var body; + if (!this.match(")") && this.config.tolerant) { + this.tolerateUnexpectedToken(this.nextToken()); + body = this.finalize(this.createNode(), new Node2.EmptyStatement()); + } else { + this.expect(")"); + var previousInIteration = this.context.inIteration; + this.context.inIteration = true; + body = this.isolateCoverGrammar(this.parseStatement); + this.context.inIteration = previousInIteration; + } + return typeof left2 === "undefined" ? this.finalize(node, new Node2.ForStatement(init, test, update, body)) : forIn ? this.finalize(node, new Node2.ForInStatement(left2, right2, body)) : this.finalize(node, new Node2.ForOfStatement(left2, right2, body)); + }; + Parser3.prototype.parseContinueStatement = function() { + var node = this.createNode(); + this.expectKeyword("continue"); + var label = null; + if (this.lookahead.type === 3 && !this.hasLineTerminator) { + var id = this.parseVariableIdentifier(); + label = id; + var key = "$" + id.name; + if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) { + this.throwError(messages_1.Messages.UnknownLabel, id.name); + } + } + this.consumeSemicolon(); + if (label === null && !this.context.inIteration) { + this.throwError(messages_1.Messages.IllegalContinue); + } + return this.finalize(node, new Node2.ContinueStatement(label)); + }; + Parser3.prototype.parseBreakStatement = function() { + var node = this.createNode(); + this.expectKeyword("break"); + var label = null; + if (this.lookahead.type === 3 && !this.hasLineTerminator) { + var id = this.parseVariableIdentifier(); + var key = "$" + id.name; + if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) { + this.throwError(messages_1.Messages.UnknownLabel, id.name); + } + label = id; + } + this.consumeSemicolon(); + if (label === null && !this.context.inIteration && !this.context.inSwitch) { + this.throwError(messages_1.Messages.IllegalBreak); + } + return this.finalize(node, new Node2.BreakStatement(label)); + }; + Parser3.prototype.parseReturnStatement = function() { + if (!this.context.inFunctionBody) { + this.tolerateError(messages_1.Messages.IllegalReturn); + } + var node = this.createNode(); + this.expectKeyword("return"); + var hasArgument = !this.match(";") && !this.match("}") && !this.hasLineTerminator && this.lookahead.type !== 2 || this.lookahead.type === 8 || this.lookahead.type === 10; + var argument = hasArgument ? this.parseExpression() : null; + this.consumeSemicolon(); + return this.finalize(node, new Node2.ReturnStatement(argument)); + }; + Parser3.prototype.parseWithStatement = function() { + if (this.context.strict) { + this.tolerateError(messages_1.Messages.StrictModeWith); + } + var node = this.createNode(); + var body; + this.expectKeyword("with"); + this.expect("("); + var object = this.parseExpression(); + if (!this.match(")") && this.config.tolerant) { + this.tolerateUnexpectedToken(this.nextToken()); + body = this.finalize(this.createNode(), new Node2.EmptyStatement()); + } else { + this.expect(")"); + body = this.parseStatement(); + } + return this.finalize(node, new Node2.WithStatement(object, body)); + }; + Parser3.prototype.parseSwitchCase = function() { + var node = this.createNode(); + var test; + if (this.matchKeyword("default")) { + this.nextToken(); + test = null; + } else { + this.expectKeyword("case"); + test = this.parseExpression(); + } + this.expect(":"); + var consequent = []; + while (true) { + if (this.match("}") || this.matchKeyword("default") || this.matchKeyword("case")) { + break; + } + consequent.push(this.parseStatementListItem()); + } + return this.finalize(node, new Node2.SwitchCase(test, consequent)); + }; + Parser3.prototype.parseSwitchStatement = function() { + var node = this.createNode(); + this.expectKeyword("switch"); + this.expect("("); + var discriminant = this.parseExpression(); + this.expect(")"); + var previousInSwitch = this.context.inSwitch; + this.context.inSwitch = true; + var cases = []; + var defaultFound = false; + this.expect("{"); + while (true) { + if (this.match("}")) { + break; + } + var clause = this.parseSwitchCase(); + if (clause.test === null) { + if (defaultFound) { + this.throwError(messages_1.Messages.MultipleDefaultsInSwitch); + } + defaultFound = true; + } + cases.push(clause); + } + this.expect("}"); + this.context.inSwitch = previousInSwitch; + return this.finalize(node, new Node2.SwitchStatement(discriminant, cases)); + }; + Parser3.prototype.parseLabelledStatement = function() { + var node = this.createNode(); + var expr = this.parseExpression(); + var statement; + if (expr.type === syntax_1.Syntax.Identifier && this.match(":")) { + this.nextToken(); + var id = expr; + var key = "$" + id.name; + if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) { + this.throwError(messages_1.Messages.Redeclaration, "Label", id.name); + } + this.context.labelSet[key] = true; + var body = void 0; + if (this.matchKeyword("class")) { + this.tolerateUnexpectedToken(this.lookahead); + body = this.parseClassDeclaration(); + } else if (this.matchKeyword("function")) { + var token = this.lookahead; + var declaration = this.parseFunctionDeclaration(); + if (this.context.strict) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunction); + } else if (declaration.generator) { + this.tolerateUnexpectedToken(token, messages_1.Messages.GeneratorInLegacyContext); + } + body = declaration; + } else { + body = this.parseStatement(); + } + delete this.context.labelSet[key]; + statement = new Node2.LabeledStatement(id, body); + } else { + this.consumeSemicolon(); + statement = new Node2.ExpressionStatement(expr); + } + return this.finalize(node, statement); + }; + Parser3.prototype.parseThrowStatement = function() { + var node = this.createNode(); + this.expectKeyword("throw"); + if (this.hasLineTerminator) { + this.throwError(messages_1.Messages.NewlineAfterThrow); + } + var argument = this.parseExpression(); + this.consumeSemicolon(); + return this.finalize(node, new Node2.ThrowStatement(argument)); + }; + Parser3.prototype.parseCatchClause = function() { + var node = this.createNode(); + this.expectKeyword("catch"); + this.expect("("); + if (this.match(")")) { + this.throwUnexpectedToken(this.lookahead); + } + var params = []; + var param = this.parsePattern(params); + var paramMap = {}; + for (var i = 0; i < params.length; i++) { + var key = "$" + params[i].value; + if (Object.prototype.hasOwnProperty.call(paramMap, key)) { + this.tolerateError(messages_1.Messages.DuplicateBinding, params[i].value); + } + paramMap[key] = true; + } + if (this.context.strict && param.type === syntax_1.Syntax.Identifier) { + if (this.scanner.isRestrictedWord(param.name)) { + this.tolerateError(messages_1.Messages.StrictCatchVariable); + } + } + this.expect(")"); + var body = this.parseBlock(); + return this.finalize(node, new Node2.CatchClause(param, body)); + }; + Parser3.prototype.parseFinallyClause = function() { + this.expectKeyword("finally"); + return this.parseBlock(); + }; + Parser3.prototype.parseTryStatement = function() { + var node = this.createNode(); + this.expectKeyword("try"); + var block = this.parseBlock(); + var handler = this.matchKeyword("catch") ? this.parseCatchClause() : null; + var finalizer = this.matchKeyword("finally") ? this.parseFinallyClause() : null; + if (!handler && !finalizer) { + this.throwError(messages_1.Messages.NoCatchOrFinally); + } + return this.finalize(node, new Node2.TryStatement(block, handler, finalizer)); + }; + Parser3.prototype.parseDebuggerStatement = function() { + var node = this.createNode(); + this.expectKeyword("debugger"); + this.consumeSemicolon(); + return this.finalize(node, new Node2.DebuggerStatement()); + }; + Parser3.prototype.parseStatement = function() { + var statement; + switch (this.lookahead.type) { + case 1: + case 5: + case 6: + case 8: + case 10: + case 9: + statement = this.parseExpressionStatement(); + break; + case 7: + var value = this.lookahead.value; + if (value === "{") { + statement = this.parseBlock(); + } else if (value === "(") { + statement = this.parseExpressionStatement(); + } else if (value === ";") { + statement = this.parseEmptyStatement(); + } else { + statement = this.parseExpressionStatement(); + } + break; + case 3: + statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement(); + break; + case 4: + switch (this.lookahead.value) { + case "break": + statement = this.parseBreakStatement(); + break; + case "continue": + statement = this.parseContinueStatement(); + break; + case "debugger": + statement = this.parseDebuggerStatement(); + break; + case "do": + statement = this.parseDoWhileStatement(); + break; + case "for": + statement = this.parseForStatement(); + break; + case "function": + statement = this.parseFunctionDeclaration(); + break; + case "if": + statement = this.parseIfStatement(); + break; + case "return": + statement = this.parseReturnStatement(); + break; + case "switch": + statement = this.parseSwitchStatement(); + break; + case "throw": + statement = this.parseThrowStatement(); + break; + case "try": + statement = this.parseTryStatement(); + break; + case "var": + statement = this.parseVariableStatement(); + break; + case "while": + statement = this.parseWhileStatement(); + break; + case "with": + statement = this.parseWithStatement(); + break; + default: + statement = this.parseExpressionStatement(); + break; + } + break; + default: + statement = this.throwUnexpectedToken(this.lookahead); + } + return statement; + }; + Parser3.prototype.parseFunctionSourceElements = function() { + var node = this.createNode(); + this.expect("{"); + var body = this.parseDirectivePrologues(); + var previousLabelSet = this.context.labelSet; + var previousInIteration = this.context.inIteration; + var previousInSwitch = this.context.inSwitch; + var previousInFunctionBody = this.context.inFunctionBody; + this.context.labelSet = {}; + this.context.inIteration = false; + this.context.inSwitch = false; + this.context.inFunctionBody = true; + while (this.lookahead.type !== 2) { + if (this.match("}")) { + break; + } + body.push(this.parseStatementListItem()); + } + this.expect("}"); + this.context.labelSet = previousLabelSet; + this.context.inIteration = previousInIteration; + this.context.inSwitch = previousInSwitch; + this.context.inFunctionBody = previousInFunctionBody; + return this.finalize(node, new Node2.BlockStatement(body)); + }; + Parser3.prototype.validateParam = function(options, param, name) { + var key = "$" + name; + if (this.context.strict) { + if (this.scanner.isRestrictedWord(name)) { + options.stricted = param; + options.message = messages_1.Messages.StrictParamName; + } + if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) { + options.stricted = param; + options.message = messages_1.Messages.StrictParamDupe; + } + } else if (!options.firstRestricted) { + if (this.scanner.isRestrictedWord(name)) { + options.firstRestricted = param; + options.message = messages_1.Messages.StrictParamName; + } else if (this.scanner.isStrictModeReservedWord(name)) { + options.firstRestricted = param; + options.message = messages_1.Messages.StrictReservedWord; + } else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) { + options.stricted = param; + options.message = messages_1.Messages.StrictParamDupe; + } + } + if (typeof Object.defineProperty === "function") { + Object.defineProperty(options.paramSet, key, { value: true, enumerable: true, writable: true, configurable: true }); + } else { + options.paramSet[key] = true; + } + }; + Parser3.prototype.parseRestElement = function(params) { + var node = this.createNode(); + this.expect("..."); + var arg = this.parsePattern(params); + if (this.match("=")) { + this.throwError(messages_1.Messages.DefaultRestParameter); + } + if (!this.match(")")) { + this.throwError(messages_1.Messages.ParameterAfterRestParameter); + } + return this.finalize(node, new Node2.RestElement(arg)); + }; + Parser3.prototype.parseFormalParameter = function(options) { + var params = []; + var param = this.match("...") ? this.parseRestElement(params) : this.parsePatternWithDefault(params); + for (var i = 0; i < params.length; i++) { + this.validateParam(options, params[i], params[i].value); + } + options.simple = options.simple && param instanceof Node2.Identifier; + options.params.push(param); + }; + Parser3.prototype.parseFormalParameters = function(firstRestricted) { + var options; + options = { + simple: true, + params: [], + firstRestricted + }; + this.expect("("); + if (!this.match(")")) { + options.paramSet = {}; + while (this.lookahead.type !== 2) { + this.parseFormalParameter(options); + if (this.match(")")) { + break; + } + this.expect(","); + if (this.match(")")) { + break; + } + } + } + this.expect(")"); + return { + simple: options.simple, + params: options.params, + stricted: options.stricted, + firstRestricted: options.firstRestricted, + message: options.message + }; + }; + Parser3.prototype.matchAsyncFunction = function() { + var match = this.matchContextualKeyword("async"); + if (match) { + var state = this.scanner.saveState(); + this.scanner.scanComments(); + var next = this.scanner.lex(); + this.scanner.restoreState(state); + match = state.lineNumber === next.lineNumber && next.type === 4 && next.value === "function"; + } + return match; + }; + Parser3.prototype.parseFunctionDeclaration = function(identifierIsOptional) { + var node = this.createNode(); + var isAsync = this.matchContextualKeyword("async"); + if (isAsync) { + this.nextToken(); + } + this.expectKeyword("function"); + var isGenerator = isAsync ? false : this.match("*"); + if (isGenerator) { + this.nextToken(); + } + var message; + var id = null; + var firstRestricted = null; + if (!identifierIsOptional || !this.match("(")) { + var token = this.lookahead; + id = this.parseVariableIdentifier(); + if (this.context.strict) { + if (this.scanner.isRestrictedWord(token.value)) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName); + } + } else { + if (this.scanner.isRestrictedWord(token.value)) { + firstRestricted = token; + message = messages_1.Messages.StrictFunctionName; + } else if (this.scanner.isStrictModeReservedWord(token.value)) { + firstRestricted = token; + message = messages_1.Messages.StrictReservedWord; + } + } + } + var previousAllowAwait = this.context.await; + var previousAllowYield = this.context.allowYield; + this.context.await = isAsync; + this.context.allowYield = !isGenerator; + var formalParameters = this.parseFormalParameters(firstRestricted); + var params = formalParameters.params; + var stricted = formalParameters.stricted; + firstRestricted = formalParameters.firstRestricted; + if (formalParameters.message) { + message = formalParameters.message; + } + var previousStrict = this.context.strict; + var previousAllowStrictDirective = this.context.allowStrictDirective; + this.context.allowStrictDirective = formalParameters.simple; + var body = this.parseFunctionSourceElements(); + if (this.context.strict && firstRestricted) { + this.throwUnexpectedToken(firstRestricted, message); + } + if (this.context.strict && stricted) { + this.tolerateUnexpectedToken(stricted, message); + } + this.context.strict = previousStrict; + this.context.allowStrictDirective = previousAllowStrictDirective; + this.context.await = previousAllowAwait; + this.context.allowYield = previousAllowYield; + return isAsync ? this.finalize(node, new Node2.AsyncFunctionDeclaration(id, params, body)) : this.finalize(node, new Node2.FunctionDeclaration(id, params, body, isGenerator)); + }; + Parser3.prototype.parseFunctionExpression = function() { + var node = this.createNode(); + var isAsync = this.matchContextualKeyword("async"); + if (isAsync) { + this.nextToken(); + } + this.expectKeyword("function"); + var isGenerator = isAsync ? false : this.match("*"); + if (isGenerator) { + this.nextToken(); + } + var message; + var id = null; + var firstRestricted; + var previousAllowAwait = this.context.await; + var previousAllowYield = this.context.allowYield; + this.context.await = isAsync; + this.context.allowYield = !isGenerator; + if (!this.match("(")) { + var token = this.lookahead; + id = !this.context.strict && !isGenerator && this.matchKeyword("yield") ? this.parseIdentifierName() : this.parseVariableIdentifier(); + if (this.context.strict) { + if (this.scanner.isRestrictedWord(token.value)) { + this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName); + } + } else { + if (this.scanner.isRestrictedWord(token.value)) { + firstRestricted = token; + message = messages_1.Messages.StrictFunctionName; + } else if (this.scanner.isStrictModeReservedWord(token.value)) { + firstRestricted = token; + message = messages_1.Messages.StrictReservedWord; + } + } + } + var formalParameters = this.parseFormalParameters(firstRestricted); + var params = formalParameters.params; + var stricted = formalParameters.stricted; + firstRestricted = formalParameters.firstRestricted; + if (formalParameters.message) { + message = formalParameters.message; + } + var previousStrict = this.context.strict; + var previousAllowStrictDirective = this.context.allowStrictDirective; + this.context.allowStrictDirective = formalParameters.simple; + var body = this.parseFunctionSourceElements(); + if (this.context.strict && firstRestricted) { + this.throwUnexpectedToken(firstRestricted, message); + } + if (this.context.strict && stricted) { + this.tolerateUnexpectedToken(stricted, message); + } + this.context.strict = previousStrict; + this.context.allowStrictDirective = previousAllowStrictDirective; + this.context.await = previousAllowAwait; + this.context.allowYield = previousAllowYield; + return isAsync ? this.finalize(node, new Node2.AsyncFunctionExpression(id, params, body)) : this.finalize(node, new Node2.FunctionExpression(id, params, body, isGenerator)); + }; + Parser3.prototype.parseDirective = function() { + var token = this.lookahead; + var node = this.createNode(); + var expr = this.parseExpression(); + var directive = expr.type === syntax_1.Syntax.Literal ? this.getTokenRaw(token).slice(1, -1) : null; + this.consumeSemicolon(); + return this.finalize(node, directive ? new Node2.Directive(expr, directive) : new Node2.ExpressionStatement(expr)); + }; + Parser3.prototype.parseDirectivePrologues = function() { + var firstRestricted = null; + var body = []; + while (true) { + var token = this.lookahead; + if (token.type !== 8) { + break; + } + var statement = this.parseDirective(); + body.push(statement); + var directive = statement.directive; + if (typeof directive !== "string") { + break; + } + if (directive === "use strict") { + this.context.strict = true; + if (firstRestricted) { + this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral); + } + if (!this.context.allowStrictDirective) { + this.tolerateUnexpectedToken(token, messages_1.Messages.IllegalLanguageModeDirective); + } + } else { + if (!firstRestricted && token.octal) { + firstRestricted = token; + } + } + } + return body; + }; + Parser3.prototype.qualifiedPropertyName = function(token) { + switch (token.type) { + case 3: + case 8: + case 1: + case 5: + case 6: + case 4: + return true; + case 7: + return token.value === "["; + default: + break; + } + return false; + }; + Parser3.prototype.parseGetterMethod = function() { + var node = this.createNode(); + var isGenerator = false; + var previousAllowYield = this.context.allowYield; + this.context.allowYield = !isGenerator; + var formalParameters = this.parseFormalParameters(); + if (formalParameters.params.length > 0) { + this.tolerateError(messages_1.Messages.BadGetterArity); + } + var method = this.parsePropertyMethod(formalParameters); + this.context.allowYield = previousAllowYield; + return this.finalize(node, new Node2.FunctionExpression(null, formalParameters.params, method, isGenerator)); + }; + Parser3.prototype.parseSetterMethod = function() { + var node = this.createNode(); + var isGenerator = false; + var previousAllowYield = this.context.allowYield; + this.context.allowYield = !isGenerator; + var formalParameters = this.parseFormalParameters(); + if (formalParameters.params.length !== 1) { + this.tolerateError(messages_1.Messages.BadSetterArity); + } else if (formalParameters.params[0] instanceof Node2.RestElement) { + this.tolerateError(messages_1.Messages.BadSetterRestParameter); + } + var method = this.parsePropertyMethod(formalParameters); + this.context.allowYield = previousAllowYield; + return this.finalize(node, new Node2.FunctionExpression(null, formalParameters.params, method, isGenerator)); + }; + Parser3.prototype.parseGeneratorMethod = function() { + var node = this.createNode(); + var isGenerator = true; + var previousAllowYield = this.context.allowYield; + this.context.allowYield = true; + var params = this.parseFormalParameters(); + this.context.allowYield = false; + var method = this.parsePropertyMethod(params); + this.context.allowYield = previousAllowYield; + return this.finalize(node, new Node2.FunctionExpression(null, params.params, method, isGenerator)); + }; + Parser3.prototype.isStartOfExpression = function() { + var start = true; + var value = this.lookahead.value; + switch (this.lookahead.type) { + case 7: + start = value === "[" || value === "(" || value === "{" || value === "+" || value === "-" || value === "!" || value === "~" || value === "++" || value === "--" || value === "/" || value === "/="; + break; + case 4: + start = value === "class" || value === "delete" || value === "function" || value === "let" || value === "new" || value === "super" || value === "this" || value === "typeof" || value === "void" || value === "yield"; + break; + default: + break; + } + return start; + }; + Parser3.prototype.parseYieldExpression = function() { + var node = this.createNode(); + this.expectKeyword("yield"); + var argument = null; + var delegate = false; + if (!this.hasLineTerminator) { + var previousAllowYield = this.context.allowYield; + this.context.allowYield = false; + delegate = this.match("*"); + if (delegate) { + this.nextToken(); + argument = this.parseAssignmentExpression(); + } else if (this.isStartOfExpression()) { + argument = this.parseAssignmentExpression(); + } + this.context.allowYield = previousAllowYield; + } + return this.finalize(node, new Node2.YieldExpression(argument, delegate)); + }; + Parser3.prototype.parseClassElement = function(hasConstructor) { + var token = this.lookahead; + var node = this.createNode(); + var kind = ""; + var key = null; + var value = null; + var computed = false; + var method = false; + var isStatic = false; + var isAsync = false; + if (this.match("*")) { + this.nextToken(); + } else { + computed = this.match("["); + key = this.parseObjectPropertyKey(); + var id = key; + if (id.name === "static" && (this.qualifiedPropertyName(this.lookahead) || this.match("*"))) { + token = this.lookahead; + isStatic = true; + computed = this.match("["); + if (this.match("*")) { + this.nextToken(); + } else { + key = this.parseObjectPropertyKey(); + } + } + if (token.type === 3 && !this.hasLineTerminator && token.value === "async") { + var punctuator = this.lookahead.value; + if (punctuator !== ":" && punctuator !== "(" && punctuator !== "*") { + isAsync = true; + token = this.lookahead; + key = this.parseObjectPropertyKey(); + if (token.type === 3 && token.value === "constructor") { + this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync); + } + } + } + } + var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead); + if (token.type === 3) { + if (token.value === "get" && lookaheadPropertyKey) { + kind = "get"; + computed = this.match("["); + key = this.parseObjectPropertyKey(); + this.context.allowYield = false; + value = this.parseGetterMethod(); + } else if (token.value === "set" && lookaheadPropertyKey) { + kind = "set"; + computed = this.match("["); + key = this.parseObjectPropertyKey(); + value = this.parseSetterMethod(); + } + } else if (token.type === 7 && token.value === "*" && lookaheadPropertyKey) { + kind = "init"; + computed = this.match("["); + key = this.parseObjectPropertyKey(); + value = this.parseGeneratorMethod(); + method = true; + } + if (!kind && key && this.match("(")) { + kind = "init"; + value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction(); + method = true; + } + if (!kind) { + this.throwUnexpectedToken(this.lookahead); + } + if (kind === "init") { + kind = "method"; + } + if (!computed) { + if (isStatic && this.isPropertyKey(key, "prototype")) { + this.throwUnexpectedToken(token, messages_1.Messages.StaticPrototype); + } + if (!isStatic && this.isPropertyKey(key, "constructor")) { + if (kind !== "method" || !method || value && value.generator) { + this.throwUnexpectedToken(token, messages_1.Messages.ConstructorSpecialMethod); + } + if (hasConstructor.value) { + this.throwUnexpectedToken(token, messages_1.Messages.DuplicateConstructor); + } else { + hasConstructor.value = true; + } + kind = "constructor"; + } + } + return this.finalize(node, new Node2.MethodDefinition(key, computed, value, kind, isStatic)); + }; + Parser3.prototype.parseClassElementList = function() { + var body = []; + var hasConstructor = { value: false }; + this.expect("{"); + while (!this.match("}")) { + if (this.match(";")) { + this.nextToken(); + } else { + body.push(this.parseClassElement(hasConstructor)); + } + } + this.expect("}"); + return body; + }; + Parser3.prototype.parseClassBody = function() { + var node = this.createNode(); + var elementList = this.parseClassElementList(); + return this.finalize(node, new Node2.ClassBody(elementList)); + }; + Parser3.prototype.parseClassDeclaration = function(identifierIsOptional) { + var node = this.createNode(); + var previousStrict = this.context.strict; + this.context.strict = true; + this.expectKeyword("class"); + var id = identifierIsOptional && this.lookahead.type !== 3 ? null : this.parseVariableIdentifier(); + var superClass = null; + if (this.matchKeyword("extends")) { + this.nextToken(); + superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall); + } + var classBody = this.parseClassBody(); + this.context.strict = previousStrict; + return this.finalize(node, new Node2.ClassDeclaration(id, superClass, classBody)); + }; + Parser3.prototype.parseClassExpression = function() { + var node = this.createNode(); + var previousStrict = this.context.strict; + this.context.strict = true; + this.expectKeyword("class"); + var id = this.lookahead.type === 3 ? this.parseVariableIdentifier() : null; + var superClass = null; + if (this.matchKeyword("extends")) { + this.nextToken(); + superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall); + } + var classBody = this.parseClassBody(); + this.context.strict = previousStrict; + return this.finalize(node, new Node2.ClassExpression(id, superClass, classBody)); + }; + Parser3.prototype.parseModule = function() { + this.context.strict = true; + this.context.isModule = true; + this.scanner.isModule = true; + var node = this.createNode(); + var body = this.parseDirectivePrologues(); + while (this.lookahead.type !== 2) { + body.push(this.parseStatementListItem()); + } + return this.finalize(node, new Node2.Module(body)); + }; + Parser3.prototype.parseScript = function() { + var node = this.createNode(); + var body = this.parseDirectivePrologues(); + while (this.lookahead.type !== 2) { + body.push(this.parseStatementListItem()); + } + return this.finalize(node, new Node2.Script(body)); + }; + Parser3.prototype.parseModuleSpecifier = function() { + var node = this.createNode(); + if (this.lookahead.type !== 8) { + this.throwError(messages_1.Messages.InvalidModuleSpecifier); + } + var token = this.nextToken(); + var raw = this.getTokenRaw(token); + return this.finalize(node, new Node2.Literal(token.value, raw)); + }; + Parser3.prototype.parseImportSpecifier = function() { + var node = this.createNode(); + var imported; + var local; + if (this.lookahead.type === 3) { + imported = this.parseVariableIdentifier(); + local = imported; + if (this.matchContextualKeyword("as")) { + this.nextToken(); + local = this.parseVariableIdentifier(); + } + } else { + imported = this.parseIdentifierName(); + local = imported; + if (this.matchContextualKeyword("as")) { + this.nextToken(); + local = this.parseVariableIdentifier(); + } else { + this.throwUnexpectedToken(this.nextToken()); + } + } + return this.finalize(node, new Node2.ImportSpecifier(local, imported)); + }; + Parser3.prototype.parseNamedImports = function() { + this.expect("{"); + var specifiers = []; + while (!this.match("}")) { + specifiers.push(this.parseImportSpecifier()); + if (!this.match("}")) { + this.expect(","); + } + } + this.expect("}"); + return specifiers; + }; + Parser3.prototype.parseImportDefaultSpecifier = function() { + var node = this.createNode(); + var local = this.parseIdentifierName(); + return this.finalize(node, new Node2.ImportDefaultSpecifier(local)); + }; + Parser3.prototype.parseImportNamespaceSpecifier = function() { + var node = this.createNode(); + this.expect("*"); + if (!this.matchContextualKeyword("as")) { + this.throwError(messages_1.Messages.NoAsAfterImportNamespace); + } + this.nextToken(); + var local = this.parseIdentifierName(); + return this.finalize(node, new Node2.ImportNamespaceSpecifier(local)); + }; + Parser3.prototype.parseImportDeclaration = function() { + if (this.context.inFunctionBody) { + this.throwError(messages_1.Messages.IllegalImportDeclaration); + } + var node = this.createNode(); + this.expectKeyword("import"); + var src; + var specifiers = []; + if (this.lookahead.type === 8) { + src = this.parseModuleSpecifier(); + } else { + if (this.match("{")) { + specifiers = specifiers.concat(this.parseNamedImports()); + } else if (this.match("*")) { + specifiers.push(this.parseImportNamespaceSpecifier()); + } else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword("default")) { + specifiers.push(this.parseImportDefaultSpecifier()); + if (this.match(",")) { + this.nextToken(); + if (this.match("*")) { + specifiers.push(this.parseImportNamespaceSpecifier()); + } else if (this.match("{")) { + specifiers = specifiers.concat(this.parseNamedImports()); + } else { + this.throwUnexpectedToken(this.lookahead); + } + } + } else { + this.throwUnexpectedToken(this.nextToken()); + } + if (!this.matchContextualKeyword("from")) { + var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause; + this.throwError(message, this.lookahead.value); + } + this.nextToken(); + src = this.parseModuleSpecifier(); + } + this.consumeSemicolon(); + return this.finalize(node, new Node2.ImportDeclaration(specifiers, src)); + }; + Parser3.prototype.parseExportSpecifier = function() { + var node = this.createNode(); + var local = this.parseIdentifierName(); + var exported = local; + if (this.matchContextualKeyword("as")) { + this.nextToken(); + exported = this.parseIdentifierName(); + } + return this.finalize(node, new Node2.ExportSpecifier(local, exported)); + }; + Parser3.prototype.parseExportDeclaration = function() { + if (this.context.inFunctionBody) { + this.throwError(messages_1.Messages.IllegalExportDeclaration); + } + var node = this.createNode(); + this.expectKeyword("export"); + var exportDeclaration; + if (this.matchKeyword("default")) { + this.nextToken(); + if (this.matchKeyword("function")) { + var declaration = this.parseFunctionDeclaration(true); + exportDeclaration = this.finalize(node, new Node2.ExportDefaultDeclaration(declaration)); + } else if (this.matchKeyword("class")) { + var declaration = this.parseClassDeclaration(true); + exportDeclaration = this.finalize(node, new Node2.ExportDefaultDeclaration(declaration)); + } else if (this.matchContextualKeyword("async")) { + var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression(); + exportDeclaration = this.finalize(node, new Node2.ExportDefaultDeclaration(declaration)); + } else { + if (this.matchContextualKeyword("from")) { + this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value); + } + var declaration = this.match("{") ? this.parseObjectInitializer() : this.match("[") ? this.parseArrayInitializer() : this.parseAssignmentExpression(); + this.consumeSemicolon(); + exportDeclaration = this.finalize(node, new Node2.ExportDefaultDeclaration(declaration)); + } + } else if (this.match("*")) { + this.nextToken(); + if (!this.matchContextualKeyword("from")) { + var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause; + this.throwError(message, this.lookahead.value); + } + this.nextToken(); + var src = this.parseModuleSpecifier(); + this.consumeSemicolon(); + exportDeclaration = this.finalize(node, new Node2.ExportAllDeclaration(src)); + } else if (this.lookahead.type === 4) { + var declaration = void 0; + switch (this.lookahead.value) { + case "let": + case "const": + declaration = this.parseLexicalDeclaration({ inFor: false }); + break; + case "var": + case "class": + case "function": + declaration = this.parseStatementListItem(); + break; + default: + this.throwUnexpectedToken(this.lookahead); + } + exportDeclaration = this.finalize(node, new Node2.ExportNamedDeclaration(declaration, [], null)); + } else if (this.matchAsyncFunction()) { + var declaration = this.parseFunctionDeclaration(); + exportDeclaration = this.finalize(node, new Node2.ExportNamedDeclaration(declaration, [], null)); + } else { + var specifiers = []; + var source = null; + var isExportFromIdentifier = false; + this.expect("{"); + while (!this.match("}")) { + isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword("default"); + specifiers.push(this.parseExportSpecifier()); + if (!this.match("}")) { + this.expect(","); + } + } + this.expect("}"); + if (this.matchContextualKeyword("from")) { + this.nextToken(); + source = this.parseModuleSpecifier(); + this.consumeSemicolon(); + } else if (isExportFromIdentifier) { + var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause; + this.throwError(message, this.lookahead.value); + } else { + this.consumeSemicolon(); + } + exportDeclaration = this.finalize(node, new Node2.ExportNamedDeclaration(null, specifiers, source)); + } + return exportDeclaration; + }; + return Parser3; + }(); + exports2.Parser = Parser2; + }, + /* 9 */ + /***/ + function(module2, exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + function assert3(condition, message) { + if (!condition) { + throw new Error("ASSERT: " + message); + } + } + exports2.assert = assert3; + }, + /* 10 */ + /***/ + function(module2, exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var ErrorHandler = function() { + function ErrorHandler2() { + this.errors = []; + this.tolerant = false; + } + ErrorHandler2.prototype.recordError = function(error) { + this.errors.push(error); + }; + ErrorHandler2.prototype.tolerate = function(error) { + if (this.tolerant) { + this.recordError(error); + } else { + throw error; + } + }; + ErrorHandler2.prototype.constructError = function(msg, column) { + var error = new Error(msg); + try { + throw error; + } catch (base) { + if (Object.create && Object.defineProperty) { + error = Object.create(base); + Object.defineProperty(error, "column", { value: column }); + } + } + return error; + }; + ErrorHandler2.prototype.createError = function(index, line, col, description) { + var msg = "Line " + line + ": " + description; + var error = this.constructError(msg, col); + error.index = index; + error.lineNumber = line; + error.description = description; + return error; + }; + ErrorHandler2.prototype.throwError = function(index, line, col, description) { + throw this.createError(index, line, col, description); + }; + ErrorHandler2.prototype.tolerateError = function(index, line, col, description) { + var error = this.createError(index, line, col, description); + if (this.tolerant) { + this.recordError(error); + } else { + throw error; + } + }; + return ErrorHandler2; + }(); + exports2.ErrorHandler = ErrorHandler; + }, + /* 11 */ + /***/ + function(module2, exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Messages = { + BadGetterArity: "Getter must not have any formal parameters", + BadSetterArity: "Setter must have exactly one formal parameter", + BadSetterRestParameter: "Setter function argument must not be a rest parameter", + ConstructorIsAsync: "Class constructor may not be an async method", + ConstructorSpecialMethod: "Class constructor may not be an accessor", + DeclarationMissingInitializer: "Missing initializer in %0 declaration", + DefaultRestParameter: "Unexpected token =", + DuplicateBinding: "Duplicate binding %0", + DuplicateConstructor: "A class may only have one constructor", + DuplicateProtoProperty: "Duplicate __proto__ fields are not allowed in object literals", + ForInOfLoopInitializer: "%0 loop variable declaration may not have an initializer", + GeneratorInLegacyContext: "Generator declarations are not allowed in legacy contexts", + IllegalBreak: "Illegal break statement", + IllegalContinue: "Illegal continue statement", + IllegalExportDeclaration: "Unexpected token", + IllegalImportDeclaration: "Unexpected token", + IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list", + IllegalReturn: "Illegal return statement", + InvalidEscapedReservedWord: "Keyword must not contain escaped characters", + InvalidHexEscapeSequence: "Invalid hexadecimal escape sequence", + InvalidLHSInAssignment: "Invalid left-hand side in assignment", + InvalidLHSInForIn: "Invalid left-hand side in for-in", + InvalidLHSInForLoop: "Invalid left-hand side in for-loop", + InvalidModuleSpecifier: "Unexpected token", + InvalidRegExp: "Invalid regular expression", + LetInLexicalBinding: "let is disallowed as a lexically bound name", + MissingFromClause: "Unexpected token", + MultipleDefaultsInSwitch: "More than one default clause in switch statement", + NewlineAfterThrow: "Illegal newline after throw", + NoAsAfterImportNamespace: "Unexpected token", + NoCatchOrFinally: "Missing catch or finally after try", + ParameterAfterRestParameter: "Rest parameter must be last formal parameter", + Redeclaration: "%0 '%1' has already been declared", + StaticPrototype: "Classes may not have static property named prototype", + StrictCatchVariable: "Catch variable may not be eval or arguments in strict mode", + StrictDelete: "Delete of an unqualified identifier in strict mode.", + StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block", + StrictFunctionName: "Function name may not be eval or arguments in strict mode", + StrictLHSAssignment: "Assignment to eval or arguments is not allowed in strict mode", + StrictLHSPostfix: "Postfix increment/decrement may not have eval or arguments operand in strict mode", + StrictLHSPrefix: "Prefix increment/decrement may not have eval or arguments operand in strict mode", + StrictModeWith: "Strict mode code may not include a with statement", + StrictOctalLiteral: "Octal literals are not allowed in strict mode.", + StrictParamDupe: "Strict mode function may not have duplicate parameter names", + StrictParamName: "Parameter name eval or arguments is not allowed in strict mode", + StrictReservedWord: "Use of future reserved word in strict mode", + StrictVarName: "Variable name may not be eval or arguments in strict mode", + TemplateOctalLiteral: "Octal literals are not allowed in template strings.", + UnexpectedEOS: "Unexpected end of input", + UnexpectedIdentifier: "Unexpected identifier", + UnexpectedNumber: "Unexpected number", + UnexpectedReserved: "Unexpected reserved word", + UnexpectedString: "Unexpected string", + UnexpectedTemplate: "Unexpected quasi %0", + UnexpectedToken: "Unexpected token %0", + UnexpectedTokenIllegal: "Unexpected token ILLEGAL", + UnknownLabel: "Undefined label '%0'", + UnterminatedRegExp: "Invalid regular expression: missing /" + }; + }, + /* 12 */ + /***/ + function(module2, exports2, __webpack_require__) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var assert_1 = __webpack_require__(9); + var character_1 = __webpack_require__(4); + var messages_1 = __webpack_require__(11); + function hexValue(ch) { + return "0123456789abcdef".indexOf(ch.toLowerCase()); + } + function octalValue(ch) { + return "01234567".indexOf(ch); + } + var Scanner = function() { + function Scanner2(code, handler) { + this.source = code; + this.errorHandler = handler; + this.trackComment = false; + this.isModule = false; + this.length = code.length; + this.index = 0; + this.lineNumber = code.length > 0 ? 1 : 0; + this.lineStart = 0; + this.curlyStack = []; + } + Scanner2.prototype.saveState = function() { + return { + index: this.index, + lineNumber: this.lineNumber, + lineStart: this.lineStart + }; + }; + Scanner2.prototype.restoreState = function(state) { + this.index = state.index; + this.lineNumber = state.lineNumber; + this.lineStart = state.lineStart; + }; + Scanner2.prototype.eof = function() { + return this.index >= this.length; + }; + Scanner2.prototype.throwUnexpectedToken = function(message) { + if (message === void 0) { + message = messages_1.Messages.UnexpectedTokenIllegal; + } + return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message); + }; + Scanner2.prototype.tolerateUnexpectedToken = function(message) { + if (message === void 0) { + message = messages_1.Messages.UnexpectedTokenIllegal; + } + this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message); + }; + Scanner2.prototype.skipSingleLineComment = function(offset) { + var comments = []; + var start, loc; + if (this.trackComment) { + comments = []; + start = this.index - offset; + loc = { + start: { + line: this.lineNumber, + column: this.index - this.lineStart - offset + }, + end: {} + }; + } + while (!this.eof()) { + var ch = this.source.charCodeAt(this.index); + ++this.index; + if (character_1.Character.isLineTerminator(ch)) { + if (this.trackComment) { + loc.end = { + line: this.lineNumber, + column: this.index - this.lineStart - 1 + }; + var entry = { + multiLine: false, + slice: [start + offset, this.index - 1], + range: [start, this.index - 1], + loc + }; + comments.push(entry); + } + if (ch === 13 && this.source.charCodeAt(this.index) === 10) { + ++this.index; + } + ++this.lineNumber; + this.lineStart = this.index; + return comments; + } + } + if (this.trackComment) { + loc.end = { + line: this.lineNumber, + column: this.index - this.lineStart + }; + var entry = { + multiLine: false, + slice: [start + offset, this.index], + range: [start, this.index], + loc + }; + comments.push(entry); + } + return comments; + }; + Scanner2.prototype.skipMultiLineComment = function() { + var comments = []; + var start, loc; + if (this.trackComment) { + comments = []; + start = this.index - 2; + loc = { + start: { + line: this.lineNumber, + column: this.index - this.lineStart - 2 + }, + end: {} + }; + } + while (!this.eof()) { + var ch = this.source.charCodeAt(this.index); + if (character_1.Character.isLineTerminator(ch)) { + if (ch === 13 && this.source.charCodeAt(this.index + 1) === 10) { + ++this.index; + } + ++this.lineNumber; + ++this.index; + this.lineStart = this.index; + } else if (ch === 42) { + if (this.source.charCodeAt(this.index + 1) === 47) { + this.index += 2; + if (this.trackComment) { + loc.end = { + line: this.lineNumber, + column: this.index - this.lineStart + }; + var entry = { + multiLine: true, + slice: [start + 2, this.index - 2], + range: [start, this.index], + loc + }; + comments.push(entry); + } + return comments; + } + ++this.index; + } else { + ++this.index; + } + } + if (this.trackComment) { + loc.end = { + line: this.lineNumber, + column: this.index - this.lineStart + }; + var entry = { + multiLine: true, + slice: [start + 2, this.index], + range: [start, this.index], + loc + }; + comments.push(entry); + } + this.tolerateUnexpectedToken(); + return comments; + }; + Scanner2.prototype.scanComments = function() { + var comments; + if (this.trackComment) { + comments = []; + } + var start = this.index === 0; + while (!this.eof()) { + var ch = this.source.charCodeAt(this.index); + if (character_1.Character.isWhiteSpace(ch)) { + ++this.index; + } else if (character_1.Character.isLineTerminator(ch)) { + ++this.index; + if (ch === 13 && this.source.charCodeAt(this.index) === 10) { + ++this.index; + } + ++this.lineNumber; + this.lineStart = this.index; + start = true; + } else if (ch === 47) { + ch = this.source.charCodeAt(this.index + 1); + if (ch === 47) { + this.index += 2; + var comment = this.skipSingleLineComment(2); + if (this.trackComment) { + comments = comments.concat(comment); + } + start = true; + } else if (ch === 42) { + this.index += 2; + var comment = this.skipMultiLineComment(); + if (this.trackComment) { + comments = comments.concat(comment); + } + } else { + break; + } + } else if (start && ch === 45) { + if (this.source.charCodeAt(this.index + 1) === 45 && this.source.charCodeAt(this.index + 2) === 62) { + this.index += 3; + var comment = this.skipSingleLineComment(3); + if (this.trackComment) { + comments = comments.concat(comment); + } + } else { + break; + } + } else if (ch === 60 && !this.isModule) { + if (this.source.slice(this.index + 1, this.index + 4) === "!--") { + this.index += 4; + var comment = this.skipSingleLineComment(4); + if (this.trackComment) { + comments = comments.concat(comment); + } + } else { + break; + } + } else { + break; + } + } + return comments; + }; + Scanner2.prototype.isFutureReservedWord = function(id) { + switch (id) { + case "enum": + case "export": + case "import": + case "super": + return true; + default: + return false; + } + }; + Scanner2.prototype.isStrictModeReservedWord = function(id) { + switch (id) { + case "implements": + case "interface": + case "package": + case "private": + case "protected": + case "public": + case "static": + case "yield": + case "let": + return true; + default: + return false; + } + }; + Scanner2.prototype.isRestrictedWord = function(id) { + return id === "eval" || id === "arguments"; + }; + Scanner2.prototype.isKeyword = function(id) { + switch (id.length) { + case 2: + return id === "if" || id === "in" || id === "do"; + case 3: + return id === "var" || id === "for" || id === "new" || id === "try" || id === "let"; + case 4: + return id === "this" || id === "else" || id === "case" || id === "void" || id === "with" || id === "enum"; + case 5: + return id === "while" || id === "break" || id === "catch" || id === "throw" || id === "const" || id === "yield" || id === "class" || id === "super"; + case 6: + return id === "return" || id === "typeof" || id === "delete" || id === "switch" || id === "export" || id === "import"; + case 7: + return id === "default" || id === "finally" || id === "extends"; + case 8: + return id === "function" || id === "continue" || id === "debugger"; + case 10: + return id === "instanceof"; + default: + return false; + } + }; + Scanner2.prototype.codePointAt = function(i) { + var cp = this.source.charCodeAt(i); + if (cp >= 55296 && cp <= 56319) { + var second = this.source.charCodeAt(i + 1); + if (second >= 56320 && second <= 57343) { + var first = cp; + cp = (first - 55296) * 1024 + second - 56320 + 65536; + } + } + return cp; + }; + Scanner2.prototype.scanHexEscape = function(prefix) { + var len = prefix === "u" ? 4 : 2; + var code = 0; + for (var i = 0; i < len; ++i) { + if (!this.eof() && character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) { + code = code * 16 + hexValue(this.source[this.index++]); + } else { + return null; + } + } + return String.fromCharCode(code); + }; + Scanner2.prototype.scanUnicodeCodePointEscape = function() { + var ch = this.source[this.index]; + var code = 0; + if (ch === "}") { + this.throwUnexpectedToken(); + } + while (!this.eof()) { + ch = this.source[this.index++]; + if (!character_1.Character.isHexDigit(ch.charCodeAt(0))) { + break; + } + code = code * 16 + hexValue(ch); + } + if (code > 1114111 || ch !== "}") { + this.throwUnexpectedToken(); + } + return character_1.Character.fromCodePoint(code); + }; + Scanner2.prototype.getIdentifier = function() { + var start = this.index++; + while (!this.eof()) { + var ch = this.source.charCodeAt(this.index); + if (ch === 92) { + this.index = start; + return this.getComplexIdentifier(); + } else if (ch >= 55296 && ch < 57343) { + this.index = start; + return this.getComplexIdentifier(); + } + if (character_1.Character.isIdentifierPart(ch)) { + ++this.index; + } else { + break; + } + } + return this.source.slice(start, this.index); + }; + Scanner2.prototype.getComplexIdentifier = function() { + var cp = this.codePointAt(this.index); + var id = character_1.Character.fromCodePoint(cp); + this.index += id.length; + var ch; + if (cp === 92) { + if (this.source.charCodeAt(this.index) !== 117) { + this.throwUnexpectedToken(); + } + ++this.index; + if (this.source[this.index] === "{") { + ++this.index; + ch = this.scanUnicodeCodePointEscape(); + } else { + ch = this.scanHexEscape("u"); + if (ch === null || ch === "\\" || !character_1.Character.isIdentifierStart(ch.charCodeAt(0))) { + this.throwUnexpectedToken(); + } + } + id = ch; + } + while (!this.eof()) { + cp = this.codePointAt(this.index); + if (!character_1.Character.isIdentifierPart(cp)) { + break; + } + ch = character_1.Character.fromCodePoint(cp); + id += ch; + this.index += ch.length; + if (cp === 92) { + id = id.substr(0, id.length - 1); + if (this.source.charCodeAt(this.index) !== 117) { + this.throwUnexpectedToken(); + } + ++this.index; + if (this.source[this.index] === "{") { + ++this.index; + ch = this.scanUnicodeCodePointEscape(); + } else { + ch = this.scanHexEscape("u"); + if (ch === null || ch === "\\" || !character_1.Character.isIdentifierPart(ch.charCodeAt(0))) { + this.throwUnexpectedToken(); + } + } + id += ch; + } + } + return id; + }; + Scanner2.prototype.octalToDecimal = function(ch) { + var octal = ch !== "0"; + var code = octalValue(ch); + if (!this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) { + octal = true; + code = code * 8 + octalValue(this.source[this.index++]); + if ("0123".indexOf(ch) >= 0 && !this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) { + code = code * 8 + octalValue(this.source[this.index++]); + } + } + return { + code, + octal + }; + }; + Scanner2.prototype.scanIdentifier = function() { + var type; + var start = this.index; + var id = this.source.charCodeAt(start) === 92 ? this.getComplexIdentifier() : this.getIdentifier(); + if (id.length === 1) { + type = 3; + } else if (this.isKeyword(id)) { + type = 4; + } else if (id === "null") { + type = 5; + } else if (id === "true" || id === "false") { + type = 1; + } else { + type = 3; + } + if (type !== 3 && start + id.length !== this.index) { + var restore = this.index; + this.index = start; + this.tolerateUnexpectedToken(messages_1.Messages.InvalidEscapedReservedWord); + this.index = restore; + } + return { + type, + value: id, + lineNumber: this.lineNumber, + lineStart: this.lineStart, + start, + end: this.index + }; + }; + Scanner2.prototype.scanPunctuator = function() { + var start = this.index; + var str = this.source[this.index]; + switch (str) { + case "(": + case "{": + if (str === "{") { + this.curlyStack.push("{"); + } + ++this.index; + break; + case ".": + ++this.index; + if (this.source[this.index] === "." && this.source[this.index + 1] === ".") { + this.index += 2; + str = "..."; + } + break; + case "}": + ++this.index; + this.curlyStack.pop(); + break; + case ")": + case ";": + case ",": + case "[": + case "]": + case ":": + case "?": + case "~": + ++this.index; + break; + default: + str = this.source.substr(this.index, 4); + if (str === ">>>=") { + this.index += 4; + } else { + str = str.substr(0, 3); + if (str === "===" || str === "!==" || str === ">>>" || str === "<<=" || str === ">>=" || str === "**=") { + this.index += 3; + } else { + str = str.substr(0, 2); + if (str === "&&" || str === "||" || str === "==" || str === "!=" || str === "+=" || str === "-=" || str === "*=" || str === "/=" || str === "++" || str === "--" || str === "<<" || str === ">>" || str === "&=" || str === "|=" || str === "^=" || str === "%=" || str === "<=" || str === ">=" || str === "=>" || str === "**") { + this.index += 2; + } else { + str = this.source[this.index]; + if ("<>=!+-*%&|^/".indexOf(str) >= 0) { + ++this.index; + } + } + } + } + } + if (this.index === start) { + this.throwUnexpectedToken(); + } + return { + type: 7, + value: str, + lineNumber: this.lineNumber, + lineStart: this.lineStart, + start, + end: this.index + }; + }; + Scanner2.prototype.scanHexLiteral = function(start) { + var num = ""; + while (!this.eof()) { + if (!character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) { + break; + } + num += this.source[this.index++]; + } + if (num.length === 0) { + this.throwUnexpectedToken(); + } + if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) { + this.throwUnexpectedToken(); + } + return { + type: 6, + value: parseInt("0x" + num, 16), + lineNumber: this.lineNumber, + lineStart: this.lineStart, + start, + end: this.index + }; + }; + Scanner2.prototype.scanBinaryLiteral = function(start) { + var num = ""; + var ch; + while (!this.eof()) { + ch = this.source[this.index]; + if (ch !== "0" && ch !== "1") { + break; + } + num += this.source[this.index++]; + } + if (num.length === 0) { + this.throwUnexpectedToken(); + } + if (!this.eof()) { + ch = this.source.charCodeAt(this.index); + if (character_1.Character.isIdentifierStart(ch) || character_1.Character.isDecimalDigit(ch)) { + this.throwUnexpectedToken(); + } + } + return { + type: 6, + value: parseInt(num, 2), + lineNumber: this.lineNumber, + lineStart: this.lineStart, + start, + end: this.index + }; + }; + Scanner2.prototype.scanOctalLiteral = function(prefix, start) { + var num = ""; + var octal = false; + if (character_1.Character.isOctalDigit(prefix.charCodeAt(0))) { + octal = true; + num = "0" + this.source[this.index++]; + } else { + ++this.index; + } + while (!this.eof()) { + if (!character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) { + break; + } + num += this.source[this.index++]; + } + if (!octal && num.length === 0) { + this.throwUnexpectedToken(); + } + if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index)) || character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) { + this.throwUnexpectedToken(); + } + return { + type: 6, + value: parseInt(num, 8), + octal, + lineNumber: this.lineNumber, + lineStart: this.lineStart, + start, + end: this.index + }; + }; + Scanner2.prototype.isImplicitOctalLiteral = function() { + for (var i = this.index + 1; i < this.length; ++i) { + var ch = this.source[i]; + if (ch === "8" || ch === "9") { + return false; + } + if (!character_1.Character.isOctalDigit(ch.charCodeAt(0))) { + return true; + } + } + return true; + }; + Scanner2.prototype.scanNumericLiteral = function() { + var start = this.index; + var ch = this.source[start]; + assert_1.assert(character_1.Character.isDecimalDigit(ch.charCodeAt(0)) || ch === ".", "Numeric literal must start with a decimal digit or a decimal point"); + var num = ""; + if (ch !== ".") { + num = this.source[this.index++]; + ch = this.source[this.index]; + if (num === "0") { + if (ch === "x" || ch === "X") { + ++this.index; + return this.scanHexLiteral(start); + } + if (ch === "b" || ch === "B") { + ++this.index; + return this.scanBinaryLiteral(start); + } + if (ch === "o" || ch === "O") { + return this.scanOctalLiteral(ch, start); + } + if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) { + if (this.isImplicitOctalLiteral()) { + return this.scanOctalLiteral(ch, start); + } + } + } + while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) { + num += this.source[this.index++]; + } + ch = this.source[this.index]; + } + if (ch === ".") { + num += this.source[this.index++]; + while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) { + num += this.source[this.index++]; + } + ch = this.source[this.index]; + } + if (ch === "e" || ch === "E") { + num += this.source[this.index++]; + ch = this.source[this.index]; + if (ch === "+" || ch === "-") { + num += this.source[this.index++]; + } + if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) { + while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) { + num += this.source[this.index++]; + } + } else { + this.throwUnexpectedToken(); + } + } + if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) { + this.throwUnexpectedToken(); + } + return { + type: 6, + value: parseFloat(num), + lineNumber: this.lineNumber, + lineStart: this.lineStart, + start, + end: this.index + }; + }; + Scanner2.prototype.scanStringLiteral = function() { + var start = this.index; + var quote = this.source[start]; + assert_1.assert(quote === "'" || quote === '"', "String literal must starts with a quote"); + ++this.index; + var octal = false; + var str = ""; + while (!this.eof()) { + var ch = this.source[this.index++]; + if (ch === quote) { + quote = ""; + break; + } else if (ch === "\\") { + ch = this.source[this.index++]; + if (!ch || !character_1.Character.isLineTerminator(ch.charCodeAt(0))) { + switch (ch) { + case "u": + if (this.source[this.index] === "{") { + ++this.index; + str += this.scanUnicodeCodePointEscape(); + } else { + var unescaped_1 = this.scanHexEscape(ch); + if (unescaped_1 === null) { + this.throwUnexpectedToken(); + } + str += unescaped_1; + } + break; + case "x": + var unescaped = this.scanHexEscape(ch); + if (unescaped === null) { + this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence); + } + str += unescaped; + break; + case "n": + str += "\n"; + break; + case "r": + str += "\r"; + break; + case "t": + str += " "; + break; + case "b": + str += "\b"; + break; + case "f": + str += "\f"; + break; + case "v": + str += "\v"; + break; + case "8": + case "9": + str += ch; + this.tolerateUnexpectedToken(); + break; + default: + if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) { + var octToDec = this.octalToDecimal(ch); + octal = octToDec.octal || octal; + str += String.fromCharCode(octToDec.code); + } else { + str += ch; + } + break; + } + } else { + ++this.lineNumber; + if (ch === "\r" && this.source[this.index] === "\n") { + ++this.index; + } + this.lineStart = this.index; + } + } else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) { + break; + } else { + str += ch; + } + } + if (quote !== "") { + this.index = start; + this.throwUnexpectedToken(); + } + return { + type: 8, + value: str, + octal, + lineNumber: this.lineNumber, + lineStart: this.lineStart, + start, + end: this.index + }; + }; + Scanner2.prototype.scanTemplate = function() { + var cooked = ""; + var terminated = false; + var start = this.index; + var head = this.source[start] === "`"; + var tail = false; + var rawOffset = 2; + ++this.index; + while (!this.eof()) { + var ch = this.source[this.index++]; + if (ch === "`") { + rawOffset = 1; + tail = true; + terminated = true; + break; + } else if (ch === "$") { + if (this.source[this.index] === "{") { + this.curlyStack.push("${"); + ++this.index; + terminated = true; + break; + } + cooked += ch; + } else if (ch === "\\") { + ch = this.source[this.index++]; + if (!character_1.Character.isLineTerminator(ch.charCodeAt(0))) { + switch (ch) { + case "n": + cooked += "\n"; + break; + case "r": + cooked += "\r"; + break; + case "t": + cooked += " "; + break; + case "u": + if (this.source[this.index] === "{") { + ++this.index; + cooked += this.scanUnicodeCodePointEscape(); + } else { + var restore = this.index; + var unescaped_2 = this.scanHexEscape(ch); + if (unescaped_2 !== null) { + cooked += unescaped_2; + } else { + this.index = restore; + cooked += ch; + } + } + break; + case "x": + var unescaped = this.scanHexEscape(ch); + if (unescaped === null) { + this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence); + } + cooked += unescaped; + break; + case "b": + cooked += "\b"; + break; + case "f": + cooked += "\f"; + break; + case "v": + cooked += "\v"; + break; + default: + if (ch === "0") { + if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) { + this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral); + } + cooked += "\0"; + } else if (character_1.Character.isOctalDigit(ch.charCodeAt(0))) { + this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral); + } else { + cooked += ch; + } + break; + } + } else { + ++this.lineNumber; + if (ch === "\r" && this.source[this.index] === "\n") { + ++this.index; + } + this.lineStart = this.index; + } + } else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) { + ++this.lineNumber; + if (ch === "\r" && this.source[this.index] === "\n") { + ++this.index; + } + this.lineStart = this.index; + cooked += "\n"; + } else { + cooked += ch; + } + } + if (!terminated) { + this.throwUnexpectedToken(); + } + if (!head) { + this.curlyStack.pop(); + } + return { + type: 10, + value: this.source.slice(start + 1, this.index - rawOffset), + cooked, + head, + tail, + lineNumber: this.lineNumber, + lineStart: this.lineStart, + start, + end: this.index + }; + }; + Scanner2.prototype.testRegExp = function(pattern, flags) { + var astralSubstitute = "\uFFFF"; + var tmp = pattern; + var self2 = this; + if (flags.indexOf("u") >= 0) { + tmp = tmp.replace(/\\u\{([0-9a-fA-F]+)\}|\\u([a-fA-F0-9]{4})/g, function($0, $1, $2) { + var codePoint = parseInt($1 || $2, 16); + if (codePoint > 1114111) { + self2.throwUnexpectedToken(messages_1.Messages.InvalidRegExp); + } + if (codePoint <= 65535) { + return String.fromCharCode(codePoint); + } + return astralSubstitute; + }).replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, astralSubstitute); + } + try { + RegExp(tmp); + } catch (e) { + this.throwUnexpectedToken(messages_1.Messages.InvalidRegExp); + } + try { + return new RegExp(pattern, flags); + } catch (exception) { + return null; + } + }; + Scanner2.prototype.scanRegExpBody = function() { + var ch = this.source[this.index]; + assert_1.assert(ch === "/", "Regular expression literal must start with a slash"); + var str = this.source[this.index++]; + var classMarker = false; + var terminated = false; + while (!this.eof()) { + ch = this.source[this.index++]; + str += ch; + if (ch === "\\") { + ch = this.source[this.index++]; + if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) { + this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp); + } + str += ch; + } else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) { + this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp); + } else if (classMarker) { + if (ch === "]") { + classMarker = false; + } + } else { + if (ch === "/") { + terminated = true; + break; + } else if (ch === "[") { + classMarker = true; + } + } + } + if (!terminated) { + this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp); + } + return str.substr(1, str.length - 2); + }; + Scanner2.prototype.scanRegExpFlags = function() { + var str = ""; + var flags = ""; + while (!this.eof()) { + var ch = this.source[this.index]; + if (!character_1.Character.isIdentifierPart(ch.charCodeAt(0))) { + break; + } + ++this.index; + if (ch === "\\" && !this.eof()) { + ch = this.source[this.index]; + if (ch === "u") { + ++this.index; + var restore = this.index; + var char = this.scanHexEscape("u"); + if (char !== null) { + flags += char; + for (str += "\\u"; restore < this.index; ++restore) { + str += this.source[restore]; + } + } else { + this.index = restore; + flags += "u"; + str += "\\u"; + } + this.tolerateUnexpectedToken(); + } else { + str += "\\"; + this.tolerateUnexpectedToken(); + } + } else { + flags += ch; + str += ch; + } + } + return flags; + }; + Scanner2.prototype.scanRegExp = function() { + var start = this.index; + var pattern = this.scanRegExpBody(); + var flags = this.scanRegExpFlags(); + var value = this.testRegExp(pattern, flags); + return { + type: 9, + value: "", + pattern, + flags, + regex: value, + lineNumber: this.lineNumber, + lineStart: this.lineStart, + start, + end: this.index + }; + }; + Scanner2.prototype.lex = function() { + if (this.eof()) { + return { + type: 2, + value: "", + lineNumber: this.lineNumber, + lineStart: this.lineStart, + start: this.index, + end: this.index + }; + } + var cp = this.source.charCodeAt(this.index); + if (character_1.Character.isIdentifierStart(cp)) { + return this.scanIdentifier(); + } + if (cp === 40 || cp === 41 || cp === 59) { + return this.scanPunctuator(); + } + if (cp === 39 || cp === 34) { + return this.scanStringLiteral(); + } + if (cp === 46) { + if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1))) { + return this.scanNumericLiteral(); + } + return this.scanPunctuator(); + } + if (character_1.Character.isDecimalDigit(cp)) { + return this.scanNumericLiteral(); + } + if (cp === 96 || cp === 125 && this.curlyStack[this.curlyStack.length - 1] === "${") { + return this.scanTemplate(); + } + if (cp >= 55296 && cp < 57343) { + if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) { + return this.scanIdentifier(); + } + } + return this.scanPunctuator(); + }; + return Scanner2; + }(); + exports2.Scanner = Scanner; + }, + /* 13 */ + /***/ + function(module2, exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.TokenName = {}; + exports2.TokenName[ + 1 + /* BooleanLiteral */ + ] = "Boolean"; + exports2.TokenName[ + 2 + /* EOF */ + ] = ""; + exports2.TokenName[ + 3 + /* Identifier */ + ] = "Identifier"; + exports2.TokenName[ + 4 + /* Keyword */ + ] = "Keyword"; + exports2.TokenName[ + 5 + /* NullLiteral */ + ] = "Null"; + exports2.TokenName[ + 6 + /* NumericLiteral */ + ] = "Numeric"; + exports2.TokenName[ + 7 + /* Punctuator */ + ] = "Punctuator"; + exports2.TokenName[ + 8 + /* StringLiteral */ + ] = "String"; + exports2.TokenName[ + 9 + /* RegularExpression */ + ] = "RegularExpression"; + exports2.TokenName[ + 10 + /* Template */ + ] = "Template"; + }, + /* 14 */ + /***/ + function(module2, exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.XHTMLEntities = { + quot: '"', + amp: "&", + apos: "'", + gt: ">", + nbsp: "\xA0", + iexcl: "\xA1", + cent: "\xA2", + pound: "\xA3", + curren: "\xA4", + yen: "\xA5", + brvbar: "\xA6", + sect: "\xA7", + uml: "\xA8", + copy: "\xA9", + ordf: "\xAA", + laquo: "\xAB", + not: "\xAC", + shy: "\xAD", + reg: "\xAE", + macr: "\xAF", + deg: "\xB0", + plusmn: "\xB1", + sup2: "\xB2", + sup3: "\xB3", + acute: "\xB4", + micro: "\xB5", + para: "\xB6", + middot: "\xB7", + cedil: "\xB8", + sup1: "\xB9", + ordm: "\xBA", + raquo: "\xBB", + frac14: "\xBC", + frac12: "\xBD", + frac34: "\xBE", + iquest: "\xBF", + Agrave: "\xC0", + Aacute: "\xC1", + Acirc: "\xC2", + Atilde: "\xC3", + Auml: "\xC4", + Aring: "\xC5", + AElig: "\xC6", + Ccedil: "\xC7", + Egrave: "\xC8", + Eacute: "\xC9", + Ecirc: "\xCA", + Euml: "\xCB", + Igrave: "\xCC", + Iacute: "\xCD", + Icirc: "\xCE", + Iuml: "\xCF", + ETH: "\xD0", + Ntilde: "\xD1", + Ograve: "\xD2", + Oacute: "\xD3", + Ocirc: "\xD4", + Otilde: "\xD5", + Ouml: "\xD6", + times: "\xD7", + Oslash: "\xD8", + Ugrave: "\xD9", + Uacute: "\xDA", + Ucirc: "\xDB", + Uuml: "\xDC", + Yacute: "\xDD", + THORN: "\xDE", + szlig: "\xDF", + agrave: "\xE0", + aacute: "\xE1", + acirc: "\xE2", + atilde: "\xE3", + auml: "\xE4", + aring: "\xE5", + aelig: "\xE6", + ccedil: "\xE7", + egrave: "\xE8", + eacute: "\xE9", + ecirc: "\xEA", + euml: "\xEB", + igrave: "\xEC", + iacute: "\xED", + icirc: "\xEE", + iuml: "\xEF", + eth: "\xF0", + ntilde: "\xF1", + ograve: "\xF2", + oacute: "\xF3", + ocirc: "\xF4", + otilde: "\xF5", + ouml: "\xF6", + divide: "\xF7", + oslash: "\xF8", + ugrave: "\xF9", + uacute: "\xFA", + ucirc: "\xFB", + uuml: "\xFC", + yacute: "\xFD", + thorn: "\xFE", + yuml: "\xFF", + OElig: "\u0152", + oelig: "\u0153", + Scaron: "\u0160", + scaron: "\u0161", + Yuml: "\u0178", + fnof: "\u0192", + circ: "\u02C6", + tilde: "\u02DC", + Alpha: "\u0391", + Beta: "\u0392", + Gamma: "\u0393", + Delta: "\u0394", + Epsilon: "\u0395", + Zeta: "\u0396", + Eta: "\u0397", + Theta: "\u0398", + Iota: "\u0399", + Kappa: "\u039A", + Lambda: "\u039B", + Mu: "\u039C", + Nu: "\u039D", + Xi: "\u039E", + Omicron: "\u039F", + Pi: "\u03A0", + Rho: "\u03A1", + Sigma: "\u03A3", + Tau: "\u03A4", + Upsilon: "\u03A5", + Phi: "\u03A6", + Chi: "\u03A7", + Psi: "\u03A8", + Omega: "\u03A9", + alpha: "\u03B1", + beta: "\u03B2", + gamma: "\u03B3", + delta: "\u03B4", + epsilon: "\u03B5", + zeta: "\u03B6", + eta: "\u03B7", + theta: "\u03B8", + iota: "\u03B9", + kappa: "\u03BA", + lambda: "\u03BB", + mu: "\u03BC", + nu: "\u03BD", + xi: "\u03BE", + omicron: "\u03BF", + pi: "\u03C0", + rho: "\u03C1", + sigmaf: "\u03C2", + sigma: "\u03C3", + tau: "\u03C4", + upsilon: "\u03C5", + phi: "\u03C6", + chi: "\u03C7", + psi: "\u03C8", + omega: "\u03C9", + thetasym: "\u03D1", + upsih: "\u03D2", + piv: "\u03D6", + ensp: "\u2002", + emsp: "\u2003", + thinsp: "\u2009", + zwnj: "\u200C", + zwj: "\u200D", + lrm: "\u200E", + rlm: "\u200F", + ndash: "\u2013", + mdash: "\u2014", + lsquo: "\u2018", + rsquo: "\u2019", + sbquo: "\u201A", + ldquo: "\u201C", + rdquo: "\u201D", + bdquo: "\u201E", + dagger: "\u2020", + Dagger: "\u2021", + bull: "\u2022", + hellip: "\u2026", + permil: "\u2030", + prime: "\u2032", + Prime: "\u2033", + lsaquo: "\u2039", + rsaquo: "\u203A", + oline: "\u203E", + frasl: "\u2044", + euro: "\u20AC", + image: "\u2111", + weierp: "\u2118", + real: "\u211C", + trade: "\u2122", + alefsym: "\u2135", + larr: "\u2190", + uarr: "\u2191", + rarr: "\u2192", + darr: "\u2193", + harr: "\u2194", + crarr: "\u21B5", + lArr: "\u21D0", + uArr: "\u21D1", + rArr: "\u21D2", + dArr: "\u21D3", + hArr: "\u21D4", + forall: "\u2200", + part: "\u2202", + exist: "\u2203", + empty: "\u2205", + nabla: "\u2207", + isin: "\u2208", + notin: "\u2209", + ni: "\u220B", + prod: "\u220F", + sum: "\u2211", + minus: "\u2212", + lowast: "\u2217", + radic: "\u221A", + prop: "\u221D", + infin: "\u221E", + ang: "\u2220", + and: "\u2227", + or: "\u2228", + cap: "\u2229", + cup: "\u222A", + int: "\u222B", + there4: "\u2234", + sim: "\u223C", + cong: "\u2245", + asymp: "\u2248", + ne: "\u2260", + equiv: "\u2261", + le: "\u2264", + ge: "\u2265", + sub: "\u2282", + sup: "\u2283", + nsub: "\u2284", + sube: "\u2286", + supe: "\u2287", + oplus: "\u2295", + otimes: "\u2297", + perp: "\u22A5", + sdot: "\u22C5", + lceil: "\u2308", + rceil: "\u2309", + lfloor: "\u230A", + rfloor: "\u230B", + loz: "\u25CA", + spades: "\u2660", + clubs: "\u2663", + hearts: "\u2665", + diams: "\u2666", + lang: "\u27E8", + rang: "\u27E9" + }; + }, + /* 15 */ + /***/ + function(module2, exports2, __webpack_require__) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var error_handler_1 = __webpack_require__(10); + var scanner_1 = __webpack_require__(12); + var token_1 = __webpack_require__(13); + var Reader = function() { + function Reader2() { + this.values = []; + this.curly = this.paren = -1; + } + Reader2.prototype.beforeFunctionExpression = function(t) { + return [ + "(", + "{", + "[", + "in", + "typeof", + "instanceof", + "new", + "return", + "case", + "delete", + "throw", + "void", + // assignment operators + "=", + "+=", + "-=", + "*=", + "**=", + "/=", + "%=", + "<<=", + ">>=", + ">>>=", + "&=", + "|=", + "^=", + ",", + // binary/unary operators + "+", + "-", + "*", + "**", + "/", + "%", + "++", + "--", + "<<", + ">>", + ">>>", + "&", + "|", + "^", + "!", + "~", + "&&", + "||", + "?", + ":", + "===", + "==", + ">=", + "<=", + "<", + ">", + "!=", + "!==" + ].indexOf(t) >= 0; + }; + Reader2.prototype.isRegexStart = function() { + var previous = this.values[this.values.length - 1]; + var regex = previous !== null; + switch (previous) { + case "this": + case "]": + regex = false; + break; + case ")": + var keyword = this.values[this.paren - 1]; + regex = keyword === "if" || keyword === "while" || keyword === "for" || keyword === "with"; + break; + case "}": + regex = false; + if (this.values[this.curly - 3] === "function") { + var check = this.values[this.curly - 4]; + regex = check ? !this.beforeFunctionExpression(check) : false; + } else if (this.values[this.curly - 4] === "function") { + var check = this.values[this.curly - 5]; + regex = check ? !this.beforeFunctionExpression(check) : true; + } + break; + default: + break; + } + return regex; + }; + Reader2.prototype.push = function(token) { + if (token.type === 7 || token.type === 4) { + if (token.value === "{") { + this.curly = this.values.length; + } else if (token.value === "(") { + this.paren = this.values.length; + } + this.values.push(token.value); + } else { + this.values.push(null); + } + }; + return Reader2; + }(); + var Tokenizer = function() { + function Tokenizer2(code, config2) { + this.errorHandler = new error_handler_1.ErrorHandler(); + this.errorHandler.tolerant = config2 ? typeof config2.tolerant === "boolean" && config2.tolerant : false; + this.scanner = new scanner_1.Scanner(code, this.errorHandler); + this.scanner.trackComment = config2 ? typeof config2.comment === "boolean" && config2.comment : false; + this.trackRange = config2 ? typeof config2.range === "boolean" && config2.range : false; + this.trackLoc = config2 ? typeof config2.loc === "boolean" && config2.loc : false; + this.buffer = []; + this.reader = new Reader(); + } + Tokenizer2.prototype.errors = function() { + return this.errorHandler.errors; + }; + Tokenizer2.prototype.getNextToken = function() { + if (this.buffer.length === 0) { + var comments = this.scanner.scanComments(); + if (this.scanner.trackComment) { + for (var i = 0; i < comments.length; ++i) { + var e = comments[i]; + var value = this.scanner.source.slice(e.slice[0], e.slice[1]); + var comment = { + type: e.multiLine ? "BlockComment" : "LineComment", + value + }; + if (this.trackRange) { + comment.range = e.range; + } + if (this.trackLoc) { + comment.loc = e.loc; + } + this.buffer.push(comment); + } + } + if (!this.scanner.eof()) { + var loc = void 0; + if (this.trackLoc) { + loc = { + start: { + line: this.scanner.lineNumber, + column: this.scanner.index - this.scanner.lineStart + }, + end: {} + }; + } + var startRegex = this.scanner.source[this.scanner.index] === "/" && this.reader.isRegexStart(); + var token = startRegex ? this.scanner.scanRegExp() : this.scanner.lex(); + this.reader.push(token); + var entry = { + type: token_1.TokenName[token.type], + value: this.scanner.source.slice(token.start, token.end) + }; + if (this.trackRange) { + entry.range = [token.start, token.end]; + } + if (this.trackLoc) { + loc.end = { + line: this.scanner.lineNumber, + column: this.scanner.index - this.scanner.lineStart + }; + entry.loc = loc; + } + if (token.type === 9) { + var pattern = token.pattern; + var flags = token.flags; + entry.regex = { pattern, flags }; + } + this.buffer.push(entry); + } + } + return this.buffer.shift(); + }; + return Tokenizer2; + }(); + exports2.Tokenizer = Tokenizer; + } + /******/ + ]) + ); + }); + } +}); + +// ../testeranto/node_modules/tslib/tslib.es6.mjs +var tslib_es6_exports = {}; +__export(tslib_es6_exports, { + __addDisposableResource: () => __addDisposableResource5, + __assign: () => __assign, + __asyncDelegator: () => __asyncDelegator, + __asyncGenerator: () => __asyncGenerator, + __asyncValues: () => __asyncValues, + __await: () => __await, + __awaiter: () => __awaiter, + __classPrivateFieldGet: () => __classPrivateFieldGet, + __classPrivateFieldIn: () => __classPrivateFieldIn, + __classPrivateFieldSet: () => __classPrivateFieldSet, + __createBinding: () => __createBinding, + __decorate: () => __decorate, + __disposeResources: () => __disposeResources5, + __esDecorate: () => __esDecorate3, + __exportStar: () => __exportStar, + __extends: () => __extends, + __generator: () => __generator, + __importDefault: () => __importDefault, + __importStar: () => __importStar, + __makeTemplateObject: () => __makeTemplateObject, + __metadata: () => __metadata, + __param: () => __param, + __propKey: () => __propKey, + __read: () => __read, + __rest: () => __rest, + __rewriteRelativeImportExtension: () => __rewriteRelativeImportExtension, + __runInitializers: () => __runInitializers3, + __setFunctionName: () => __setFunctionName, + __spread: () => __spread, + __spreadArray: () => __spreadArray, + __spreadArrays: () => __spreadArrays, + __values: () => __values, + default: () => tslib_es6_default +}); +function __extends(d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +} +function __rest(s, e) { + var t = {}; + for (var p in s) + if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +} +function __decorate(decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + r = Reflect.decorate(decorators, target, key, desc); + else + for (var i = decorators.length - 1; i >= 0; i--) + if (d = decorators[i]) + r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +} +function __param(paramIndex, decorator) { + return function(target, key) { + decorator(target, key, paramIndex); + }; +} +function __esDecorate3(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; +} +function __runInitializers3(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; +} +function __propKey(x) { + return typeof x === "symbol" ? x : "".concat(x); +} +function __setFunctionName(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 }); +} +function __metadata(metadataKey, metadataValue) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(metadataKey, metadataValue); +} +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve5) { + resolve5(value); + }); + } + return new (P || (P = Promise))(function(resolve5, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } + } + 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 _ = { label: 0, sent: function() { + if (t[0] & 1) + throw t[1]; + return t[1]; + }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype); + return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { + return this; + }), g; + function verb(n) { + return function(v) { + return step([n, v]); + }; + } + function step(op) { + if (f) + throw new TypeError("Generator is already executing."); + while (g && (g = 0, op[0] && (_ = 0)), _) + try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) + return t; + if (y = 0, t) + op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: + case 1: + t = op; + break; + case 4: + _.label++; + return { value: op[1], done: false }; + case 5: + _.label++; + y = op[1]; + op = [0]; + continue; + case 7: + op = _.ops.pop(); + _.trys.pop(); + continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { + _ = 0; + continue; + } + if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { + _.label = op[1]; + break; + } + if (op[0] === 6 && _.label < t[1]) { + _.label = t[1]; + t = op; + break; + } + if (t && _.label < t[2]) { + _.label = t[2]; + _.ops.push(op); + break; + } + if (t[2]) + _.ops.pop(); + _.trys.pop(); + continue; + } + op = body.call(thisArg, _); + } catch (e) { + op = [6, e]; + y = 0; + } finally { + f = t = 0; + } + if (op[0] & 5) + throw op[1]; + return { value: op[0] ? op[1] : void 0, done: true }; + } +} +function __exportStar(m, o) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) + __createBinding(o, m, p); +} +function __values(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) + return m.call(o); + if (o && typeof o.length === "number") + return { + next: function() { + if (o && i >= o.length) + o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +} +function __read(o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) + return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) + ar.push(r.value); + } catch (error) { + e = { error }; + } finally { + try { + if (r && !r.done && (m = i["return"])) + m.call(i); + } finally { + if (e) + throw e.error; + } + } + return ar; +} +function __spread() { + for (var ar = [], i = 0; i < arguments.length; i++) + ar = ar.concat(__read(arguments[i])); + return ar; +} +function __spreadArrays() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) + s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; +} +function __spreadArray(to, from2, pack) { + if (pack || arguments.length === 2) + for (var i = 0, l = from2.length, ar; i < l; i++) { + if (ar || !(i in from2)) { + if (!ar) + ar = Array.prototype.slice.call(from2, 0, i); + ar[i] = from2[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from2)); +} +function __await(v) { + return this instanceof __await ? (this.v = v, this) : new __await(v); +} +function __asyncGenerator(thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) + throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() { + return this; + }, i; + function awaitReturn(f) { + return function(v) { + return Promise.resolve(v).then(f, reject); + }; + } + function verb(n, f) { + if (g[n]) { + i[n] = function(v) { + return new Promise(function(a, b) { + q.push([n, v, a, b]) > 1 || resume(n, v); + }); + }; + if (f) + i[n] = f(i[n]); + } + } + function resume(n, v) { + try { + step(g[n](v)); + } catch (e) { + settle(q[0][3], e); + } + } + function step(r) { + r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); + } + function fulfill(value) { + resume("next", value); + } + function reject(value) { + resume("throw", value); + } + function settle(f, v) { + if (f(v), q.shift(), q.length) + resume(q[0][0], q[0][1]); + } +} +function __asyncDelegator(o) { + var i, p; + return i = {}, verb("next"), verb("throw", function(e) { + throw e; + }), verb("return"), i[Symbol.iterator] = function() { + return this; + }, i; + function verb(n, f) { + i[n] = o[n] ? function(v) { + return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; + } : f; + } +} +function __asyncValues(o) { + if (!Symbol.asyncIterator) + throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() { + return this; + }, i); + function verb(n) { + i[n] = o[n] && function(v) { + return new Promise(function(resolve5, reject) { + v = o[n](v), settle(resolve5, reject, v.done, v.value); + }); + }; + } + function settle(resolve5, reject, d, v) { + Promise.resolve(v).then(function(v2) { + resolve5({ value: v2, done: d }); + }, reject); + } +} +function __makeTemplateObject(cooked, raw) { + if (Object.defineProperty) { + Object.defineProperty(cooked, "raw", { value: raw }); + } else { + cooked.raw = raw; + } + return cooked; +} +function __importStar(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k = ownKeys(mod), i = 0; i < k.length; i++) + if (k[i] !== "default") + __createBinding(result, mod, k[i]); + } + __setModuleDefault(result, mod); + return result; +} +function __importDefault(mod) { + return mod && mod.__esModule ? mod : { default: mod }; +} +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} +function __classPrivateFieldSet(receiver, state, value, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; +} +function __classPrivateFieldIn(state, receiver) { + if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function") + throw new TypeError("Cannot use 'in' operator on non-object"); + return typeof state === "function" ? receiver === state : state.has(receiver); +} +function __addDisposableResource5(env2, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env2.stack.push({ value, dispose, async }); + } else if (async) { + env2.stack.push({ async: true }); + } + return value; +} +function __disposeResources5(env2) { + function fail(e) { + env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e; + env2.hasError = true; + } + var r, s = 0; + function next() { + while (r = env2.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env2.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env2.hasError ? Promise.reject(env2.error) : Promise.resolve(); + if (env2.hasError) + throw env2.error; + } + return next(); +} +function __rewriteRelativeImportExtension(path10, preserveJsx) { + if (typeof path10 === "string" && /^\.\.?\//.test(path10)) { + return path10.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) { + return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js"; + }); + } + return path10; +} +var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys, _SuppressedError, tslib_es6_default; +var init_tslib_es6 = __esm({ + "../testeranto/node_modules/tslib/tslib.es6.mjs"() { + init_cjs_shim(); + extendStatics = function(d, b) { + extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) { + d2.__proto__ = b2; + } || function(d2, b2) { + for (var p in b2) + if (Object.prototype.hasOwnProperty.call(b2, p)) + d2[p] = b2[p]; + }; + return extendStatics(d, b); + }; + __assign = function() { + __assign = Object.assign || function __assign2(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) + if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); + }; + __createBinding = Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }; + __setModuleDefault = Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }; + ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function(o2) { + var ar = []; + for (var k in o2) + if (Object.prototype.hasOwnProperty.call(o2, k)) + ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; + }; + tslib_es6_default = { + __extends, + __assign, + __rest, + __decorate, + __param, + __esDecorate: __esDecorate3, + __runInitializers: __runInitializers3, + __propKey, + __setFunctionName, + __metadata, + __awaiter, + __generator, + __createBinding, + __exportStar, + __values, + __read, + __spread, + __spreadArrays, + __spreadArray, + __await, + __asyncGenerator, + __asyncDelegator, + __asyncValues, + __makeTemplateObject, + __importStar, + __importDefault, + __classPrivateFieldGet, + __classPrivateFieldSet, + __classPrivateFieldIn, + __addDisposableResource: __addDisposableResource5, + __disposeResources: __disposeResources5, + __rewriteRelativeImportExtension + }; + } +}); + +// ../testeranto/node_modules/ast-types/lib/types.js +var require_types = __commonJS({ + "../testeranto/node_modules/ast-types/lib/types.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Def = void 0; + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var Op = Object.prototype; + var objToStr = Op.toString; + var hasOwn = Op.hasOwnProperty; + var BaseType = ( + /** @class */ + function() { + function BaseType2() { + } + BaseType2.prototype.assert = function(value, deep) { + if (!this.check(value, deep)) { + var str = shallowStringify(value); + throw new Error(str + " does not match type " + this); + } + return true; + }; + BaseType2.prototype.arrayOf = function() { + var elemType = this; + return new ArrayType(elemType); + }; + return BaseType2; + }() + ); + var ArrayType = ( + /** @class */ + function(_super) { + tslib_1.__extends(ArrayType2, _super); + function ArrayType2(elemType) { + var _this = _super.call(this) || this; + _this.elemType = elemType; + _this.kind = "ArrayType"; + return _this; + } + ArrayType2.prototype.toString = function() { + return "[" + this.elemType + "]"; + }; + ArrayType2.prototype.check = function(value, deep) { + var _this = this; + return Array.isArray(value) && value.every(function(elem) { + return _this.elemType.check(elem, deep); + }); + }; + return ArrayType2; + }(BaseType) + ); + var IdentityType = ( + /** @class */ + function(_super) { + tslib_1.__extends(IdentityType2, _super); + function IdentityType2(value) { + var _this = _super.call(this) || this; + _this.value = value; + _this.kind = "IdentityType"; + return _this; + } + IdentityType2.prototype.toString = function() { + return String(this.value); + }; + IdentityType2.prototype.check = function(value, deep) { + var result = value === this.value; + if (!result && typeof deep === "function") { + deep(this, value); + } + return result; + }; + return IdentityType2; + }(BaseType) + ); + var ObjectType = ( + /** @class */ + function(_super) { + tslib_1.__extends(ObjectType2, _super); + function ObjectType2(fields) { + var _this = _super.call(this) || this; + _this.fields = fields; + _this.kind = "ObjectType"; + return _this; + } + ObjectType2.prototype.toString = function() { + return "{ " + this.fields.join(", ") + " }"; + }; + ObjectType2.prototype.check = function(value, deep) { + return objToStr.call(value) === objToStr.call({}) && this.fields.every(function(field) { + return field.type.check(value[field.name], deep); + }); + }; + return ObjectType2; + }(BaseType) + ); + var OrType = ( + /** @class */ + function(_super) { + tslib_1.__extends(OrType2, _super); + function OrType2(types) { + var _this = _super.call(this) || this; + _this.types = types; + _this.kind = "OrType"; + return _this; + } + OrType2.prototype.toString = function() { + return this.types.join(" | "); + }; + OrType2.prototype.check = function(value, deep) { + return this.types.some(function(type) { + return type.check(value, deep); + }); + }; + return OrType2; + }(BaseType) + ); + var PredicateType = ( + /** @class */ + function(_super) { + tslib_1.__extends(PredicateType2, _super); + function PredicateType2(name, predicate) { + var _this = _super.call(this) || this; + _this.name = name; + _this.predicate = predicate; + _this.kind = "PredicateType"; + return _this; + } + PredicateType2.prototype.toString = function() { + return this.name; + }; + PredicateType2.prototype.check = function(value, deep) { + var result = this.predicate(value, deep); + if (!result && typeof deep === "function") { + deep(this, value); + } + return result; + }; + return PredicateType2; + }(BaseType) + ); + var Def = ( + /** @class */ + function() { + function Def2(type, typeName) { + this.type = type; + this.typeName = typeName; + this.baseNames = []; + this.ownFields = /* @__PURE__ */ Object.create(null); + this.allSupertypes = /* @__PURE__ */ Object.create(null); + this.supertypeList = []; + this.allFields = /* @__PURE__ */ Object.create(null); + this.fieldNames = []; + this.finalized = false; + this.buildable = false; + this.buildParams = []; + } + Def2.prototype.isSupertypeOf = function(that) { + if (that instanceof Def2) { + if (this.finalized !== true || that.finalized !== true) { + throw new Error(""); + } + return hasOwn.call(that.allSupertypes, this.typeName); + } else { + throw new Error(that + " is not a Def"); + } + }; + Def2.prototype.checkAllFields = function(value, deep) { + var allFields = this.allFields; + if (this.finalized !== true) { + throw new Error("" + this.typeName); + } + function checkFieldByName(name) { + var field = allFields[name]; + var type = field.type; + var child = field.getValue(value); + return type.check(child, deep); + } + return value !== null && typeof value === "object" && Object.keys(allFields).every(checkFieldByName); + }; + Def2.prototype.bases = function() { + var supertypeNames = []; + for (var _i = 0; _i < arguments.length; _i++) { + supertypeNames[_i] = arguments[_i]; + } + var bases = this.baseNames; + if (this.finalized) { + if (supertypeNames.length !== bases.length) { + throw new Error(""); + } + for (var i = 0; i < supertypeNames.length; i++) { + if (supertypeNames[i] !== bases[i]) { + throw new Error(""); + } + } + return this; + } + supertypeNames.forEach(function(baseName) { + if (bases.indexOf(baseName) < 0) { + bases.push(baseName); + } + }); + return this; + }; + return Def2; + }() + ); + exports.Def = Def; + var Field = ( + /** @class */ + function() { + function Field2(name, type, defaultFn, hidden) { + this.name = name; + this.type = type; + this.defaultFn = defaultFn; + this.hidden = !!hidden; + } + Field2.prototype.toString = function() { + return JSON.stringify(this.name) + ": " + this.type; + }; + Field2.prototype.getValue = function(obj) { + var value = obj[this.name]; + if (typeof value !== "undefined") { + return value; + } + if (typeof this.defaultFn === "function") { + value = this.defaultFn.call(obj); + } + return value; + }; + return Field2; + }() + ); + function shallowStringify(value) { + if (Array.isArray(value)) { + return "[" + value.map(shallowStringify).join(", ") + "]"; + } + if (value && typeof value === "object") { + return "{ " + Object.keys(value).map(function(key) { + return key + ": " + value[key]; + }).join(", ") + " }"; + } + return JSON.stringify(value); + } + function typesPlugin(_fork) { + var Type = { + or: function() { + var types = []; + for (var _i = 0; _i < arguments.length; _i++) { + types[_i] = arguments[_i]; + } + return new OrType(types.map(function(type) { + return Type.from(type); + })); + }, + from: function(value, name) { + if (value instanceof ArrayType || value instanceof IdentityType || value instanceof ObjectType || value instanceof OrType || value instanceof PredicateType) { + return value; + } + if (value instanceof Def) { + return value.type; + } + if (isArray.check(value)) { + if (value.length !== 1) { + throw new Error("only one element type is permitted for typed arrays"); + } + return new ArrayType(Type.from(value[0])); + } + if (isObject.check(value)) { + return new ObjectType(Object.keys(value).map(function(name2) { + return new Field(name2, Type.from(value[name2], name2)); + })); + } + if (typeof value === "function") { + var bicfIndex = builtInCtorFns.indexOf(value); + if (bicfIndex >= 0) { + return builtInCtorTypes[bicfIndex]; + } + if (typeof name !== "string") { + throw new Error("missing name"); + } + return new PredicateType(name, value); + } + return new IdentityType(value); + }, + // Define a type whose name is registered in a namespace (the defCache) so + // that future definitions will return the same type given the same name. + // In particular, this system allows for circular and forward definitions. + // The Def object d returned from Type.def may be used to configure the + // type d.type by calling methods such as d.bases, d.build, and d.field. + def: function(typeName) { + return hasOwn.call(defCache, typeName) ? defCache[typeName] : defCache[typeName] = new DefImpl(typeName); + }, + hasDef: function(typeName) { + return hasOwn.call(defCache, typeName); + } + }; + var builtInCtorFns = []; + var builtInCtorTypes = []; + function defBuiltInType(name, example) { + var objStr = objToStr.call(example); + var type = new PredicateType(name, function(value) { + return objToStr.call(value) === objStr; + }); + if (example && typeof example.constructor === "function") { + builtInCtorFns.push(example.constructor); + builtInCtorTypes.push(type); + } + return type; + } + var isString2 = defBuiltInType("string", "truthy"); + var isFunction2 = defBuiltInType("function", function() { + }); + var isArray = defBuiltInType("array", []); + var isObject = defBuiltInType("object", {}); + var isRegExp = defBuiltInType("RegExp", /./); + var isDate = defBuiltInType("Date", /* @__PURE__ */ new Date()); + var isNumber = defBuiltInType("number", 3); + var isBoolean2 = defBuiltInType("boolean", true); + var isNull = defBuiltInType("null", null); + var isUndefined = defBuiltInType("undefined", void 0); + var builtInTypes = { + string: isString2, + function: isFunction2, + array: isArray, + object: isObject, + RegExp: isRegExp, + Date: isDate, + number: isNumber, + boolean: isBoolean2, + null: isNull, + undefined: isUndefined + }; + var defCache = /* @__PURE__ */ Object.create(null); + function defFromValue(value) { + if (value && typeof value === "object") { + var type = value.type; + if (typeof type === "string" && hasOwn.call(defCache, type)) { + var d = defCache[type]; + if (d.finalized) { + return d; + } + } + } + return null; + } + var DefImpl = ( + /** @class */ + function(_super) { + tslib_1.__extends(DefImpl2, _super); + function DefImpl2(typeName) { + var _this = _super.call(this, new PredicateType(typeName, function(value, deep) { + return _this.check(value, deep); + }), typeName) || this; + return _this; + } + DefImpl2.prototype.check = function(value, deep) { + if (this.finalized !== true) { + throw new Error("prematurely checking unfinalized type " + this.typeName); + } + if (value === null || typeof value !== "object") { + return false; + } + var vDef = defFromValue(value); + if (!vDef) { + if (this.typeName === "SourceLocation" || this.typeName === "Position") { + return this.checkAllFields(value, deep); + } + return false; + } + if (deep && vDef === this) { + return this.checkAllFields(value, deep); + } + if (!this.isSupertypeOf(vDef)) { + return false; + } + if (!deep) { + return true; + } + return vDef.checkAllFields(value, deep) && this.checkAllFields(value, false); + }; + DefImpl2.prototype.build = function() { + var _this = this; + var buildParams = []; + for (var _i = 0; _i < arguments.length; _i++) { + buildParams[_i] = arguments[_i]; + } + this.buildParams = buildParams; + if (this.buildable) { + return this; + } + this.field("type", String, function() { + return _this.typeName; + }); + this.buildable = true; + var addParam = function(built, param, arg, isArgAvailable) { + if (hasOwn.call(built, param)) + return; + var all = _this.allFields; + if (!hasOwn.call(all, param)) { + throw new Error("" + param); + } + var field = all[param]; + var type = field.type; + var value; + if (isArgAvailable) { + value = arg; + } else if (field.defaultFn) { + value = field.defaultFn.call(built); + } else { + var message = "no value or default function given for field " + JSON.stringify(param) + " of " + _this.typeName + "(" + _this.buildParams.map(function(name) { + return all[name]; + }).join(", ") + ")"; + throw new Error(message); + } + if (!type.check(value)) { + throw new Error(shallowStringify(value) + " does not match field " + field + " of type " + _this.typeName); + } + built[param] = value; + }; + var builder = function() { + var args = []; + for (var _i2 = 0; _i2 < arguments.length; _i2++) { + args[_i2] = arguments[_i2]; + } + var argc = args.length; + if (!_this.finalized) { + throw new Error("attempting to instantiate unfinalized type " + _this.typeName); + } + var built = Object.create(nodePrototype); + _this.buildParams.forEach(function(param, i) { + if (i < argc) { + addParam(built, param, args[i], true); + } else { + addParam(built, param, null, false); + } + }); + Object.keys(_this.allFields).forEach(function(param) { + addParam(built, param, null, false); + }); + if (built.type !== _this.typeName) { + throw new Error(""); + } + return built; + }; + builder.from = function(obj) { + if (!_this.finalized) { + throw new Error("attempting to instantiate unfinalized type " + _this.typeName); + } + var built = Object.create(nodePrototype); + Object.keys(_this.allFields).forEach(function(param) { + if (hasOwn.call(obj, param)) { + addParam(built, param, obj[param], true); + } else { + addParam(built, param, null, false); + } + }); + if (built.type !== _this.typeName) { + throw new Error(""); + } + return built; + }; + Object.defineProperty(builders, getBuilderName(this.typeName), { + enumerable: true, + value: builder + }); + return this; + }; + DefImpl2.prototype.field = function(name, type, defaultFn, hidden) { + if (this.finalized) { + console.error("Ignoring attempt to redefine field " + JSON.stringify(name) + " of finalized type " + JSON.stringify(this.typeName)); + return this; + } + this.ownFields[name] = new Field(name, Type.from(type), defaultFn, hidden); + return this; + }; + DefImpl2.prototype.finalize = function() { + var _this = this; + if (!this.finalized) { + var allFields = this.allFields; + var allSupertypes = this.allSupertypes; + this.baseNames.forEach(function(name) { + var def = defCache[name]; + if (def instanceof Def) { + def.finalize(); + extend(allFields, def.allFields); + extend(allSupertypes, def.allSupertypes); + } else { + var message = "unknown supertype name " + JSON.stringify(name) + " for subtype " + JSON.stringify(_this.typeName); + throw new Error(message); + } + }); + extend(allFields, this.ownFields); + allSupertypes[this.typeName] = this; + this.fieldNames.length = 0; + for (var fieldName in allFields) { + if (hasOwn.call(allFields, fieldName) && !allFields[fieldName].hidden) { + this.fieldNames.push(fieldName); + } + } + Object.defineProperty(namedTypes, this.typeName, { + enumerable: true, + value: this.type + }); + this.finalized = true; + populateSupertypeList(this.typeName, this.supertypeList); + if (this.buildable && this.supertypeList.lastIndexOf("Expression") >= 0) { + wrapExpressionBuilderWithStatement(this.typeName); + } + } + }; + return DefImpl2; + }(Def) + ); + function getSupertypeNames(typeName) { + if (!hasOwn.call(defCache, typeName)) { + throw new Error(""); + } + var d = defCache[typeName]; + if (d.finalized !== true) { + throw new Error(""); + } + return d.supertypeList.slice(1); + } + function computeSupertypeLookupTable(candidates) { + var table = {}; + var typeNames = Object.keys(defCache); + var typeNameCount = typeNames.length; + for (var i = 0; i < typeNameCount; ++i) { + var typeName = typeNames[i]; + var d = defCache[typeName]; + if (d.finalized !== true) { + throw new Error("" + typeName); + } + for (var j = 0; j < d.supertypeList.length; ++j) { + var superTypeName = d.supertypeList[j]; + if (hasOwn.call(candidates, superTypeName)) { + table[typeName] = superTypeName; + break; + } + } + } + return table; + } + var builders = /* @__PURE__ */ Object.create(null); + var nodePrototype = {}; + function defineMethod(name, func) { + var old = nodePrototype[name]; + if (isUndefined.check(func)) { + delete nodePrototype[name]; + } else { + isFunction2.assert(func); + Object.defineProperty(nodePrototype, name, { + enumerable: true, + configurable: true, + value: func + }); + } + return old; + } + function getBuilderName(typeName) { + return typeName.replace(/^[A-Z]+/, function(upperCasePrefix) { + var len = upperCasePrefix.length; + switch (len) { + case 0: + return ""; + case 1: + return upperCasePrefix.toLowerCase(); + default: + return upperCasePrefix.slice(0, len - 1).toLowerCase() + upperCasePrefix.charAt(len - 1); + } + }); + } + function getStatementBuilderName(typeName) { + typeName = getBuilderName(typeName); + return typeName.replace(/(Expression)?$/, "Statement"); + } + var namedTypes = {}; + function getFieldNames(object) { + var d = defFromValue(object); + if (d) { + return d.fieldNames.slice(0); + } + if ("type" in object) { + throw new Error("did not recognize object of type " + JSON.stringify(object.type)); + } + return Object.keys(object); + } + function getFieldValue(object, fieldName) { + var d = defFromValue(object); + if (d) { + var field = d.allFields[fieldName]; + if (field) { + return field.getValue(object); + } + } + return object && object[fieldName]; + } + function eachField(object, callback, context) { + getFieldNames(object).forEach(function(name) { + callback.call(this, name, getFieldValue(object, name)); + }, context); + } + function someField(object, callback, context) { + return getFieldNames(object).some(function(name) { + return callback.call(this, name, getFieldValue(object, name)); + }, context); + } + function wrapExpressionBuilderWithStatement(typeName) { + var wrapperName = getStatementBuilderName(typeName); + if (builders[wrapperName]) + return; + var wrapped = builders[getBuilderName(typeName)]; + if (!wrapped) + return; + var builder = function() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return builders.expressionStatement(wrapped.apply(builders, args)); + }; + builder.from = function() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return builders.expressionStatement(wrapped.from.apply(builders, args)); + }; + builders[wrapperName] = builder; + } + function populateSupertypeList(typeName, list) { + list.length = 0; + list.push(typeName); + var lastSeen = /* @__PURE__ */ Object.create(null); + for (var pos = 0; pos < list.length; ++pos) { + typeName = list[pos]; + var d = defCache[typeName]; + if (d.finalized !== true) { + throw new Error(""); + } + if (hasOwn.call(lastSeen, typeName)) { + delete list[lastSeen[typeName]]; + } + lastSeen[typeName] = pos; + list.push.apply(list, d.baseNames); + } + for (var to = 0, from2 = to, len = list.length; from2 < len; ++from2) { + if (hasOwn.call(list, from2)) { + list[to++] = list[from2]; + } + } + list.length = to; + } + function extend(into, from2) { + Object.keys(from2).forEach(function(name) { + into[name] = from2[name]; + }); + return into; + } + function finalize() { + Object.keys(defCache).forEach(function(name) { + defCache[name].finalize(); + }); + } + return { + Type, + builtInTypes, + getSupertypeNames, + computeSupertypeLookupTable, + builders, + defineMethod, + getBuilderName, + getStatementBuilderName, + namedTypes, + getFieldNames, + getFieldValue, + eachField, + someField, + finalize + }; + } + exports.default = typesPlugin; + } +}); + +// ../testeranto/node_modules/ast-types/lib/path.js +var require_path = __commonJS({ + "../testeranto/node_modules/ast-types/lib/path.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var types_1 = tslib_1.__importDefault(require_types()); + var Op = Object.prototype; + var hasOwn = Op.hasOwnProperty; + function pathPlugin(fork) { + var types = fork.use(types_1.default); + var isArray = types.builtInTypes.array; + var isNumber = types.builtInTypes.number; + var Path = function Path2(value, parentPath, name) { + if (!(this instanceof Path2)) { + throw new Error("Path constructor cannot be invoked without 'new'"); + } + if (parentPath) { + if (!(parentPath instanceof Path2)) { + throw new Error(""); + } + } else { + parentPath = null; + name = null; + } + this.value = value; + this.parentPath = parentPath; + this.name = name; + this.__childCache = null; + }; + var Pp = Path.prototype; + function getChildCache(path10) { + return path10.__childCache || (path10.__childCache = /* @__PURE__ */ Object.create(null)); + } + function getChildPath(path10, name) { + var cache = getChildCache(path10); + var actualChildValue = path10.getValueProperty(name); + var childPath = cache[name]; + if (!hasOwn.call(cache, name) || // Ensure consistency between cache and reality. + childPath.value !== actualChildValue) { + childPath = cache[name] = new path10.constructor(actualChildValue, path10, name); + } + return childPath; + } + Pp.getValueProperty = function getValueProperty(name) { + return this.value[name]; + }; + Pp.get = function get() { + var names = []; + for (var _i = 0; _i < arguments.length; _i++) { + names[_i] = arguments[_i]; + } + var path10 = this; + var count = names.length; + for (var i = 0; i < count; ++i) { + path10 = getChildPath(path10, names[i]); + } + return path10; + }; + Pp.each = function each(callback, context) { + var childPaths = []; + var len = this.value.length; + var i = 0; + for (var i = 0; i < len; ++i) { + if (hasOwn.call(this.value, i)) { + childPaths[i] = this.get(i); + } + } + context = context || this; + for (i = 0; i < len; ++i) { + if (hasOwn.call(childPaths, i)) { + callback.call(context, childPaths[i]); + } + } + }; + Pp.map = function map2(callback, context) { + var result = []; + this.each(function(childPath) { + result.push(callback.call(this, childPath)); + }, context); + return result; + }; + Pp.filter = function filter2(callback, context) { + var result = []; + this.each(function(childPath) { + if (callback.call(this, childPath)) { + result.push(childPath); + } + }, context); + return result; + }; + function emptyMoves() { + } + function getMoves(path10, offset, start, end) { + isArray.assert(path10.value); + if (offset === 0) { + return emptyMoves; + } + var length = path10.value.length; + if (length < 1) { + return emptyMoves; + } + var argc = arguments.length; + if (argc === 2) { + start = 0; + end = length; + } else if (argc === 3) { + start = Math.max(start, 0); + end = length; + } else { + start = Math.max(start, 0); + end = Math.min(end, length); + } + isNumber.assert(start); + isNumber.assert(end); + var moves = /* @__PURE__ */ Object.create(null); + var cache = getChildCache(path10); + for (var i = start; i < end; ++i) { + if (hasOwn.call(path10.value, i)) { + var childPath = path10.get(i); + if (childPath.name !== i) { + throw new Error(""); + } + var newIndex = i + offset; + childPath.name = newIndex; + moves[newIndex] = childPath; + delete cache[i]; + } + } + delete cache.length; + return function() { + for (var newIndex2 in moves) { + var childPath2 = moves[newIndex2]; + if (childPath2.name !== +newIndex2) { + throw new Error(""); + } + cache[newIndex2] = childPath2; + path10.value[newIndex2] = childPath2.value; + } + }; + } + Pp.shift = function shift() { + var move = getMoves(this, -1); + var result = this.value.shift(); + move(); + return result; + }; + Pp.unshift = function unshift() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var move = getMoves(this, args.length); + var result = this.value.unshift.apply(this.value, args); + move(); + return result; + }; + Pp.push = function push() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + isArray.assert(this.value); + delete getChildCache(this).length; + return this.value.push.apply(this.value, args); + }; + Pp.pop = function pop() { + isArray.assert(this.value); + var cache = getChildCache(this); + delete cache[this.value.length - 1]; + delete cache.length; + return this.value.pop(); + }; + Pp.insertAt = function insertAt(index) { + var argc = arguments.length; + var move = getMoves(this, argc - 1, index); + if (move === emptyMoves && argc <= 1) { + return this; + } + index = Math.max(index, 0); + for (var i = 1; i < argc; ++i) { + this.value[index + i - 1] = arguments[i]; + } + move(); + return this; + }; + Pp.insertBefore = function insertBefore() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var pp = this.parentPath; + var argc = args.length; + var insertAtArgs = [this.name]; + for (var i = 0; i < argc; ++i) { + insertAtArgs.push(args[i]); + } + return pp.insertAt.apply(pp, insertAtArgs); + }; + Pp.insertAfter = function insertAfter() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var pp = this.parentPath; + var argc = args.length; + var insertAtArgs = [this.name + 1]; + for (var i = 0; i < argc; ++i) { + insertAtArgs.push(args[i]); + } + return pp.insertAt.apply(pp, insertAtArgs); + }; + function repairRelationshipWithParent(path10) { + if (!(path10 instanceof Path)) { + throw new Error(""); + } + var pp = path10.parentPath; + if (!pp) { + return path10; + } + var parentValue = pp.value; + var parentCache = getChildCache(pp); + if (parentValue[path10.name] === path10.value) { + parentCache[path10.name] = path10; + } else if (isArray.check(parentValue)) { + var i = parentValue.indexOf(path10.value); + if (i >= 0) { + parentCache[path10.name = i] = path10; + } + } else { + parentValue[path10.name] = path10.value; + parentCache[path10.name] = path10; + } + if (parentValue[path10.name] !== path10.value) { + throw new Error(""); + } + if (path10.parentPath.get(path10.name) !== path10) { + throw new Error(""); + } + return path10; + } + Pp.replace = function replace(replacement) { + var results = []; + var parentValue = this.parentPath.value; + var parentCache = getChildCache(this.parentPath); + var count = arguments.length; + repairRelationshipWithParent(this); + if (isArray.check(parentValue)) { + var originalLength = parentValue.length; + var move = getMoves(this.parentPath, count - 1, this.name + 1); + var spliceArgs = [this.name, 1]; + for (var i = 0; i < count; ++i) { + spliceArgs.push(arguments[i]); + } + var splicedOut = parentValue.splice.apply(parentValue, spliceArgs); + if (splicedOut[0] !== this.value) { + throw new Error(""); + } + if (parentValue.length !== originalLength - 1 + count) { + throw new Error(""); + } + move(); + if (count === 0) { + delete this.value; + delete parentCache[this.name]; + this.__childCache = null; + } else { + if (parentValue[this.name] !== replacement) { + throw new Error(""); + } + if (this.value !== replacement) { + this.value = replacement; + this.__childCache = null; + } + for (i = 0; i < count; ++i) { + results.push(this.parentPath.get(this.name + i)); + } + if (results[0] !== this) { + throw new Error(""); + } + } + } else if (count === 1) { + if (this.value !== replacement) { + this.__childCache = null; + } + this.value = parentValue[this.name] = replacement; + results.push(this); + } else if (count === 0) { + delete parentValue[this.name]; + delete this.value; + this.__childCache = null; + } else { + throw new Error("Could not replace path"); + } + return results; + }; + return Path; + } + exports.default = pathPlugin; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/lib/scope.js +var require_scope = __commonJS({ + "../testeranto/node_modules/ast-types/lib/scope.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var types_1 = tslib_1.__importDefault(require_types()); + var hasOwn = Object.prototype.hasOwnProperty; + function scopePlugin(fork) { + var types = fork.use(types_1.default); + var Type = types.Type; + var namedTypes = types.namedTypes; + var Node2 = namedTypes.Node; + var Expression = namedTypes.Expression; + var isArray = types.builtInTypes.array; + var b = types.builders; + var Scope = function Scope2(path10, parentScope) { + if (!(this instanceof Scope2)) { + throw new Error("Scope constructor cannot be invoked without 'new'"); + } + ScopeType.assert(path10.value); + var depth; + if (parentScope) { + if (!(parentScope instanceof Scope2)) { + throw new Error(""); + } + depth = parentScope.depth + 1; + } else { + parentScope = null; + depth = 0; + } + Object.defineProperties(this, { + path: { value: path10 }, + node: { value: path10.value }, + isGlobal: { value: !parentScope, enumerable: true }, + depth: { value: depth }, + parent: { value: parentScope }, + bindings: { value: {} }, + types: { value: {} } + }); + }; + var scopeTypes = [ + // Program nodes introduce global scopes. + namedTypes.Program, + // Function is the supertype of FunctionExpression, + // FunctionDeclaration, ArrowExpression, etc. + namedTypes.Function, + // In case you didn't know, the caught parameter shadows any variable + // of the same name in an outer scope. + namedTypes.CatchClause + ]; + var ScopeType = Type.or.apply(Type, scopeTypes); + Scope.isEstablishedBy = function(node) { + return ScopeType.check(node); + }; + var Sp = Scope.prototype; + Sp.didScan = false; + Sp.declares = function(name) { + this.scan(); + return hasOwn.call(this.bindings, name); + }; + Sp.declaresType = function(name) { + this.scan(); + return hasOwn.call(this.types, name); + }; + Sp.declareTemporary = function(prefix) { + if (prefix) { + if (!/^[a-z$_]/i.test(prefix)) { + throw new Error(""); + } + } else { + prefix = "t$"; + } + prefix += this.depth.toString(36) + "$"; + this.scan(); + var index = 0; + while (this.declares(prefix + index)) { + ++index; + } + var name = prefix + index; + return this.bindings[name] = types.builders.identifier(name); + }; + Sp.injectTemporary = function(identifier, init) { + identifier || (identifier = this.declareTemporary()); + var bodyPath = this.path.get("body"); + if (namedTypes.BlockStatement.check(bodyPath.value)) { + bodyPath = bodyPath.get("body"); + } + bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init || null)])); + return identifier; + }; + Sp.scan = function(force) { + if (force || !this.didScan) { + for (var name in this.bindings) { + delete this.bindings[name]; + } + scanScope(this.path, this.bindings, this.types); + this.didScan = true; + } + }; + Sp.getBindings = function() { + this.scan(); + return this.bindings; + }; + Sp.getTypes = function() { + this.scan(); + return this.types; + }; + function scanScope(path10, bindings, scopeTypes2) { + var node = path10.value; + ScopeType.assert(node); + if (namedTypes.CatchClause.check(node)) { + var param = path10.get("param"); + if (param.value) { + addPattern(param, bindings); + } + } else { + recursiveScanScope(path10, bindings, scopeTypes2); + } + } + function recursiveScanScope(path10, bindings, scopeTypes2) { + var node = path10.value; + if (path10.parent && namedTypes.FunctionExpression.check(path10.parent.node) && path10.parent.node.id) { + addPattern(path10.parent.get("id"), bindings); + } + if (!node) { + } else if (isArray.check(node)) { + path10.each(function(childPath) { + recursiveScanChild(childPath, bindings, scopeTypes2); + }); + } else if (namedTypes.Function.check(node)) { + path10.get("params").each(function(paramPath) { + addPattern(paramPath, bindings); + }); + recursiveScanChild(path10.get("body"), bindings, scopeTypes2); + } else if (namedTypes.TypeAlias && namedTypes.TypeAlias.check(node) || namedTypes.InterfaceDeclaration && namedTypes.InterfaceDeclaration.check(node) || namedTypes.TSTypeAliasDeclaration && namedTypes.TSTypeAliasDeclaration.check(node) || namedTypes.TSInterfaceDeclaration && namedTypes.TSInterfaceDeclaration.check(node)) { + addTypePattern(path10.get("id"), scopeTypes2); + } else if (namedTypes.VariableDeclarator.check(node)) { + addPattern(path10.get("id"), bindings); + recursiveScanChild(path10.get("init"), bindings, scopeTypes2); + } else if (node.type === "ImportSpecifier" || node.type === "ImportNamespaceSpecifier" || node.type === "ImportDefaultSpecifier") { + addPattern( + // Esprima used to use the .name field to refer to the local + // binding identifier for ImportSpecifier nodes, but .id for + // ImportNamespaceSpecifier and ImportDefaultSpecifier nodes. + // ESTree/Acorn/ESpree use .local for all three node types. + path10.get(node.local ? "local" : node.name ? "name" : "id"), + bindings + ); + } else if (Node2.check(node) && !Expression.check(node)) { + types.eachField(node, function(name, child) { + var childPath = path10.get(name); + if (!pathHasValue(childPath, child)) { + throw new Error(""); + } + recursiveScanChild(childPath, bindings, scopeTypes2); + }); + } + } + function pathHasValue(path10, value) { + if (path10.value === value) { + return true; + } + if (Array.isArray(path10.value) && path10.value.length === 0 && Array.isArray(value) && value.length === 0) { + return true; + } + return false; + } + function recursiveScanChild(path10, bindings, scopeTypes2) { + var node = path10.value; + if (!node || Expression.check(node)) { + } else if (namedTypes.FunctionDeclaration.check(node) && node.id !== null) { + addPattern(path10.get("id"), bindings); + } else if (namedTypes.ClassDeclaration && namedTypes.ClassDeclaration.check(node)) { + addPattern(path10.get("id"), bindings); + } else if (ScopeType.check(node)) { + if (namedTypes.CatchClause.check(node) && // TODO Broaden this to accept any pattern. + namedTypes.Identifier.check(node.param)) { + var catchParamName = node.param.name; + var hadBinding = hasOwn.call(bindings, catchParamName); + recursiveScanScope(path10.get("body"), bindings, scopeTypes2); + if (!hadBinding) { + delete bindings[catchParamName]; + } + } + } else { + recursiveScanScope(path10, bindings, scopeTypes2); + } + } + function addPattern(patternPath, bindings) { + var pattern = patternPath.value; + namedTypes.Pattern.assert(pattern); + if (namedTypes.Identifier.check(pattern)) { + if (hasOwn.call(bindings, pattern.name)) { + bindings[pattern.name].push(patternPath); + } else { + bindings[pattern.name] = [patternPath]; + } + } else if (namedTypes.AssignmentPattern && namedTypes.AssignmentPattern.check(pattern)) { + addPattern(patternPath.get("left"), bindings); + } else if (namedTypes.ObjectPattern && namedTypes.ObjectPattern.check(pattern)) { + patternPath.get("properties").each(function(propertyPath) { + var property = propertyPath.value; + if (namedTypes.Pattern.check(property)) { + addPattern(propertyPath, bindings); + } else if (namedTypes.Property.check(property)) { + addPattern(propertyPath.get("value"), bindings); + } else if (namedTypes.SpreadProperty && namedTypes.SpreadProperty.check(property)) { + addPattern(propertyPath.get("argument"), bindings); + } + }); + } else if (namedTypes.ArrayPattern && namedTypes.ArrayPattern.check(pattern)) { + patternPath.get("elements").each(function(elementPath) { + var element = elementPath.value; + if (namedTypes.Pattern.check(element)) { + addPattern(elementPath, bindings); + } else if (namedTypes.SpreadElement && namedTypes.SpreadElement.check(element)) { + addPattern(elementPath.get("argument"), bindings); + } + }); + } else if (namedTypes.PropertyPattern && namedTypes.PropertyPattern.check(pattern)) { + addPattern(patternPath.get("pattern"), bindings); + } else if (namedTypes.SpreadElementPattern && namedTypes.SpreadElementPattern.check(pattern) || namedTypes.SpreadPropertyPattern && namedTypes.SpreadPropertyPattern.check(pattern)) { + addPattern(patternPath.get("argument"), bindings); + } + } + function addTypePattern(patternPath, types2) { + var pattern = patternPath.value; + namedTypes.Pattern.assert(pattern); + if (namedTypes.Identifier.check(pattern)) { + if (hasOwn.call(types2, pattern.name)) { + types2[pattern.name].push(patternPath); + } else { + types2[pattern.name] = [patternPath]; + } + } + } + Sp.lookup = function(name) { + for (var scope = this; scope; scope = scope.parent) + if (scope.declares(name)) + break; + return scope; + }; + Sp.lookupType = function(name) { + for (var scope = this; scope; scope = scope.parent) + if (scope.declaresType(name)) + break; + return scope; + }; + Sp.getGlobalScope = function() { + var scope = this; + while (!scope.isGlobal) + scope = scope.parent; + return scope; + }; + return Scope; + } + exports.default = scopePlugin; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/lib/node-path.js +var require_node_path = __commonJS({ + "../testeranto/node_modules/ast-types/lib/node-path.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var types_1 = tslib_1.__importDefault(require_types()); + var path_1 = tslib_1.__importDefault(require_path()); + var scope_1 = tslib_1.__importDefault(require_scope()); + function nodePathPlugin(fork) { + var types = fork.use(types_1.default); + var n = types.namedTypes; + var b = types.builders; + var isNumber = types.builtInTypes.number; + var isArray = types.builtInTypes.array; + var Path = fork.use(path_1.default); + var Scope = fork.use(scope_1.default); + var NodePath = function NodePath2(value, parentPath, name) { + if (!(this instanceof NodePath2)) { + throw new Error("NodePath constructor cannot be invoked without 'new'"); + } + Path.call(this, value, parentPath, name); + }; + var NPp = NodePath.prototype = Object.create(Path.prototype, { + constructor: { + value: NodePath, + enumerable: false, + writable: true, + configurable: true + } + }); + Object.defineProperties(NPp, { + node: { + get: function() { + Object.defineProperty(this, "node", { + configurable: true, + value: this._computeNode() + }); + return this.node; + } + }, + parent: { + get: function() { + Object.defineProperty(this, "parent", { + configurable: true, + value: this._computeParent() + }); + return this.parent; + } + }, + scope: { + get: function() { + Object.defineProperty(this, "scope", { + configurable: true, + value: this._computeScope() + }); + return this.scope; + } + } + }); + NPp.replace = function() { + delete this.node; + delete this.parent; + delete this.scope; + return Path.prototype.replace.apply(this, arguments); + }; + NPp.prune = function() { + var remainingNodePath = this.parent; + this.replace(); + return cleanUpNodesAfterPrune(remainingNodePath); + }; + NPp._computeNode = function() { + var value = this.value; + if (n.Node.check(value)) { + return value; + } + var pp = this.parentPath; + return pp && pp.node || null; + }; + NPp._computeParent = function() { + var value = this.value; + var pp = this.parentPath; + if (!n.Node.check(value)) { + while (pp && !n.Node.check(pp.value)) { + pp = pp.parentPath; + } + if (pp) { + pp = pp.parentPath; + } + } + while (pp && !n.Node.check(pp.value)) { + pp = pp.parentPath; + } + return pp || null; + }; + NPp._computeScope = function() { + var value = this.value; + var pp = this.parentPath; + var scope = pp && pp.scope; + if (n.Node.check(value) && Scope.isEstablishedBy(value)) { + scope = new Scope(this, scope); + } + return scope || null; + }; + NPp.getValueProperty = function(name) { + return types.getFieldValue(this.value, name); + }; + NPp.needsParens = function(assumeExpressionContext) { + var pp = this.parentPath; + if (!pp) { + return false; + } + var node = this.value; + if (!n.Expression.check(node)) { + return false; + } + if (node.type === "Identifier") { + return false; + } + while (!n.Node.check(pp.value)) { + pp = pp.parentPath; + if (!pp) { + return false; + } + } + var parent = pp.value; + switch (node.type) { + case "UnaryExpression": + case "SpreadElement": + case "SpreadProperty": + return parent.type === "MemberExpression" && this.name === "object" && parent.object === node; + case "BinaryExpression": + case "LogicalExpression": + switch (parent.type) { + case "CallExpression": + return this.name === "callee" && parent.callee === node; + case "UnaryExpression": + case "SpreadElement": + case "SpreadProperty": + return true; + case "MemberExpression": + return this.name === "object" && parent.object === node; + case "BinaryExpression": + case "LogicalExpression": { + var n_1 = node; + var po = parent.operator; + var pp_1 = PRECEDENCE[po]; + var no = n_1.operator; + var np = PRECEDENCE[no]; + if (pp_1 > np) { + return true; + } + if (pp_1 === np && this.name === "right") { + if (parent.right !== n_1) { + throw new Error("Nodes must be equal"); + } + return true; + } + } + default: + return false; + } + case "SequenceExpression": + switch (parent.type) { + case "ForStatement": + return false; + case "ExpressionStatement": + return this.name !== "expression"; + default: + return true; + } + case "YieldExpression": + switch (parent.type) { + case "BinaryExpression": + case "LogicalExpression": + case "UnaryExpression": + case "SpreadElement": + case "SpreadProperty": + case "CallExpression": + case "MemberExpression": + case "NewExpression": + case "ConditionalExpression": + case "YieldExpression": + return true; + default: + return false; + } + case "Literal": + return parent.type === "MemberExpression" && isNumber.check(node.value) && this.name === "object" && parent.object === node; + case "AssignmentExpression": + case "ConditionalExpression": + switch (parent.type) { + case "UnaryExpression": + case "SpreadElement": + case "SpreadProperty": + case "BinaryExpression": + case "LogicalExpression": + return true; + case "CallExpression": + return this.name === "callee" && parent.callee === node; + case "ConditionalExpression": + return this.name === "test" && parent.test === node; + case "MemberExpression": + return this.name === "object" && parent.object === node; + default: + return false; + } + default: + if (parent.type === "NewExpression" && this.name === "callee" && parent.callee === node) { + return containsCallExpression(node); + } + } + if (assumeExpressionContext !== true && !this.canBeFirstInStatement() && this.firstInStatement()) + return true; + return false; + }; + function isBinary(node) { + return n.BinaryExpression.check(node) || n.LogicalExpression.check(node); + } + function isUnaryLike(node) { + return n.UnaryExpression.check(node) || n.SpreadElement && n.SpreadElement.check(node) || n.SpreadProperty && n.SpreadProperty.check(node); + } + var PRECEDENCE = {}; + [ + ["||"], + ["&&"], + ["|"], + ["^"], + ["&"], + ["==", "===", "!=", "!=="], + ["<", ">", "<=", ">=", "in", "instanceof"], + [">>", "<<", ">>>"], + ["+", "-"], + ["*", "/", "%"] + ].forEach(function(tier, i) { + tier.forEach(function(op) { + PRECEDENCE[op] = i; + }); + }); + function containsCallExpression(node) { + if (n.CallExpression.check(node)) { + return true; + } + if (isArray.check(node)) { + return node.some(containsCallExpression); + } + if (n.Node.check(node)) { + return types.someField(node, function(_name, child) { + return containsCallExpression(child); + }); + } + return false; + } + NPp.canBeFirstInStatement = function() { + var node = this.node; + return !n.FunctionExpression.check(node) && !n.ObjectExpression.check(node); + }; + NPp.firstInStatement = function() { + return firstInStatement(this); + }; + function firstInStatement(path10) { + for (var node, parent; path10.parent; path10 = path10.parent) { + node = path10.node; + parent = path10.parent.node; + if (n.BlockStatement.check(parent) && path10.parent.name === "body" && path10.name === 0) { + if (parent.body[0] !== node) { + throw new Error("Nodes must be equal"); + } + return true; + } + if (n.ExpressionStatement.check(parent) && path10.name === "expression") { + if (parent.expression !== node) { + throw new Error("Nodes must be equal"); + } + return true; + } + if (n.SequenceExpression.check(parent) && path10.parent.name === "expressions" && path10.name === 0) { + if (parent.expressions[0] !== node) { + throw new Error("Nodes must be equal"); + } + continue; + } + if (n.CallExpression.check(parent) && path10.name === "callee") { + if (parent.callee !== node) { + throw new Error("Nodes must be equal"); + } + continue; + } + if (n.MemberExpression.check(parent) && path10.name === "object") { + if (parent.object !== node) { + throw new Error("Nodes must be equal"); + } + continue; + } + if (n.ConditionalExpression.check(parent) && path10.name === "test") { + if (parent.test !== node) { + throw new Error("Nodes must be equal"); + } + continue; + } + if (isBinary(parent) && path10.name === "left") { + if (parent.left !== node) { + throw new Error("Nodes must be equal"); + } + continue; + } + if (n.UnaryExpression.check(parent) && !parent.prefix && path10.name === "argument") { + if (parent.argument !== node) { + throw new Error("Nodes must be equal"); + } + continue; + } + return false; + } + return true; + } + function cleanUpNodesAfterPrune(remainingNodePath) { + if (n.VariableDeclaration.check(remainingNodePath.node)) { + var declarations = remainingNodePath.get("declarations").value; + if (!declarations || declarations.length === 0) { + return remainingNodePath.prune(); + } + } else if (n.ExpressionStatement.check(remainingNodePath.node)) { + if (!remainingNodePath.get("expression").value) { + return remainingNodePath.prune(); + } + } else if (n.IfStatement.check(remainingNodePath.node)) { + cleanUpIfStatementAfterPrune(remainingNodePath); + } + return remainingNodePath; + } + function cleanUpIfStatementAfterPrune(ifStatement) { + var testExpression = ifStatement.get("test").value; + var alternate = ifStatement.get("alternate").value; + var consequent = ifStatement.get("consequent").value; + if (!consequent && !alternate) { + var testExpressionStatement = b.expressionStatement(testExpression); + ifStatement.replace(testExpressionStatement); + } else if (!consequent && alternate) { + var negatedTestExpression = b.unaryExpression("!", testExpression, true); + if (n.UnaryExpression.check(testExpression) && testExpression.operator === "!") { + negatedTestExpression = testExpression.argument; + } + ifStatement.get("test").replace(negatedTestExpression); + ifStatement.get("consequent").replace(alternate); + ifStatement.get("alternate").replace(); + } + } + return NodePath; + } + exports.default = nodePathPlugin; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/lib/path-visitor.js +var require_path_visitor = __commonJS({ + "../testeranto/node_modules/ast-types/lib/path-visitor.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var types_1 = tslib_1.__importDefault(require_types()); + var node_path_1 = tslib_1.__importDefault(require_node_path()); + var hasOwn = Object.prototype.hasOwnProperty; + function pathVisitorPlugin(fork) { + var types = fork.use(types_1.default); + var NodePath = fork.use(node_path_1.default); + var isArray = types.builtInTypes.array; + var isObject = types.builtInTypes.object; + var isFunction2 = types.builtInTypes.function; + var undefined2; + var PathVisitor = function PathVisitor2() { + if (!(this instanceof PathVisitor2)) { + throw new Error("PathVisitor constructor cannot be invoked without 'new'"); + } + this._reusableContextStack = []; + this._methodNameTable = computeMethodNameTable(this); + this._shouldVisitComments = hasOwn.call(this._methodNameTable, "Block") || hasOwn.call(this._methodNameTable, "Line"); + this.Context = makeContextConstructor(this); + this._visiting = false; + this._changeReported = false; + }; + function computeMethodNameTable(visitor) { + var typeNames = /* @__PURE__ */ Object.create(null); + for (var methodName in visitor) { + if (/^visit[A-Z]/.test(methodName)) { + typeNames[methodName.slice("visit".length)] = true; + } + } + var supertypeTable = types.computeSupertypeLookupTable(typeNames); + var methodNameTable = /* @__PURE__ */ Object.create(null); + var typeNameKeys = Object.keys(supertypeTable); + var typeNameCount = typeNameKeys.length; + for (var i = 0; i < typeNameCount; ++i) { + var typeName = typeNameKeys[i]; + methodName = "visit" + supertypeTable[typeName]; + if (isFunction2.check(visitor[methodName])) { + methodNameTable[typeName] = methodName; + } + } + return methodNameTable; + } + PathVisitor.fromMethodsObject = function fromMethodsObject(methods) { + if (methods instanceof PathVisitor) { + return methods; + } + if (!isObject.check(methods)) { + return new PathVisitor(); + } + var Visitor = function Visitor2() { + if (!(this instanceof Visitor2)) { + throw new Error("Visitor constructor cannot be invoked without 'new'"); + } + PathVisitor.call(this); + }; + var Vp = Visitor.prototype = Object.create(PVp); + Vp.constructor = Visitor; + extend(Vp, methods); + extend(Visitor, PathVisitor); + isFunction2.assert(Visitor.fromMethodsObject); + isFunction2.assert(Visitor.visit); + return new Visitor(); + }; + function extend(target, source) { + for (var property in source) { + if (hasOwn.call(source, property)) { + target[property] = source[property]; + } + } + return target; + } + PathVisitor.visit = function visit(node, methods) { + return PathVisitor.fromMethodsObject(methods).visit(node); + }; + var PVp = PathVisitor.prototype; + PVp.visit = function() { + if (this._visiting) { + throw new Error("Recursively calling visitor.visit(path) resets visitor state. Try this.visit(path) or this.traverse(path) instead."); + } + this._visiting = true; + this._changeReported = false; + this._abortRequested = false; + var argc = arguments.length; + var args = new Array(argc); + for (var i = 0; i < argc; ++i) { + args[i] = arguments[i]; + } + if (!(args[0] instanceof NodePath)) { + args[0] = new NodePath({ root: args[0] }).get("root"); + } + this.reset.apply(this, args); + var didNotThrow; + try { + var root = this.visitWithoutReset(args[0]); + didNotThrow = true; + } finally { + this._visiting = false; + if (!didNotThrow && this._abortRequested) { + return args[0].value; + } + } + return root; + }; + PVp.AbortRequest = function AbortRequest() { + }; + PVp.abort = function() { + var visitor = this; + visitor._abortRequested = true; + var request3 = new visitor.AbortRequest(); + request3.cancel = function() { + visitor._abortRequested = false; + }; + throw request3; + }; + PVp.reset = function(_path) { + }; + PVp.visitWithoutReset = function(path10) { + if (this instanceof this.Context) { + return this.visitor.visitWithoutReset(path10); + } + if (!(path10 instanceof NodePath)) { + throw new Error(""); + } + var value = path10.value; + var methodName = value && typeof value === "object" && typeof value.type === "string" && this._methodNameTable[value.type]; + if (methodName) { + var context = this.acquireContext(path10); + try { + return context.invokeVisitorMethod(methodName); + } finally { + this.releaseContext(context); + } + } else { + return visitChildren(path10, this); + } + }; + function visitChildren(path10, visitor) { + if (!(path10 instanceof NodePath)) { + throw new Error(""); + } + if (!(visitor instanceof PathVisitor)) { + throw new Error(""); + } + var value = path10.value; + if (isArray.check(value)) { + path10.each(visitor.visitWithoutReset, visitor); + } else if (!isObject.check(value)) { + } else { + var childNames = types.getFieldNames(value); + if (visitor._shouldVisitComments && value.comments && childNames.indexOf("comments") < 0) { + childNames.push("comments"); + } + var childCount = childNames.length; + var childPaths = []; + for (var i = 0; i < childCount; ++i) { + var childName = childNames[i]; + if (!hasOwn.call(value, childName)) { + value[childName] = types.getFieldValue(value, childName); + } + childPaths.push(path10.get(childName)); + } + for (var i = 0; i < childCount; ++i) { + visitor.visitWithoutReset(childPaths[i]); + } + } + return path10.value; + } + PVp.acquireContext = function(path10) { + if (this._reusableContextStack.length === 0) { + return new this.Context(path10); + } + return this._reusableContextStack.pop().reset(path10); + }; + PVp.releaseContext = function(context) { + if (!(context instanceof this.Context)) { + throw new Error(""); + } + this._reusableContextStack.push(context); + context.currentPath = null; + }; + PVp.reportChanged = function() { + this._changeReported = true; + }; + PVp.wasChangeReported = function() { + return this._changeReported; + }; + function makeContextConstructor(visitor) { + function Context(path10) { + if (!(this instanceof Context)) { + throw new Error(""); + } + if (!(this instanceof PathVisitor)) { + throw new Error(""); + } + if (!(path10 instanceof NodePath)) { + throw new Error(""); + } + Object.defineProperty(this, "visitor", { + value: visitor, + writable: false, + enumerable: true, + configurable: false + }); + this.currentPath = path10; + this.needToCallTraverse = true; + Object.seal(this); + } + if (!(visitor instanceof PathVisitor)) { + throw new Error(""); + } + var Cp = Context.prototype = Object.create(visitor); + Cp.constructor = Context; + extend(Cp, sharedContextProtoMethods); + return Context; + } + var sharedContextProtoMethods = /* @__PURE__ */ Object.create(null); + sharedContextProtoMethods.reset = function reset(path10) { + if (!(this instanceof this.Context)) { + throw new Error(""); + } + if (!(path10 instanceof NodePath)) { + throw new Error(""); + } + this.currentPath = path10; + this.needToCallTraverse = true; + return this; + }; + sharedContextProtoMethods.invokeVisitorMethod = function invokeVisitorMethod(methodName) { + if (!(this instanceof this.Context)) { + throw new Error(""); + } + if (!(this.currentPath instanceof NodePath)) { + throw new Error(""); + } + var result = this.visitor[methodName].call(this, this.currentPath); + if (result === false) { + this.needToCallTraverse = false; + } else if (result !== undefined2) { + this.currentPath = this.currentPath.replace(result)[0]; + if (this.needToCallTraverse) { + this.traverse(this.currentPath); + } + } + if (this.needToCallTraverse !== false) { + throw new Error("Must either call this.traverse or return false in " + methodName); + } + var path10 = this.currentPath; + return path10 && path10.value; + }; + sharedContextProtoMethods.traverse = function traverse(path10, newVisitor) { + if (!(this instanceof this.Context)) { + throw new Error(""); + } + if (!(path10 instanceof NodePath)) { + throw new Error(""); + } + if (!(this.currentPath instanceof NodePath)) { + throw new Error(""); + } + this.needToCallTraverse = false; + return visitChildren(path10, PathVisitor.fromMethodsObject(newVisitor || this.visitor)); + }; + sharedContextProtoMethods.visit = function visit(path10, newVisitor) { + if (!(this instanceof this.Context)) { + throw new Error(""); + } + if (!(path10 instanceof NodePath)) { + throw new Error(""); + } + if (!(this.currentPath instanceof NodePath)) { + throw new Error(""); + } + this.needToCallTraverse = false; + return PathVisitor.fromMethodsObject(newVisitor || this.visitor).visitWithoutReset(path10); + }; + sharedContextProtoMethods.reportChanged = function reportChanged() { + this.visitor.reportChanged(); + }; + sharedContextProtoMethods.abort = function abort() { + this.needToCallTraverse = false; + this.visitor.abort(); + }; + return PathVisitor; + } + exports.default = pathVisitorPlugin; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/lib/equiv.js +var require_equiv = __commonJS({ + "../testeranto/node_modules/ast-types/lib/equiv.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var types_1 = tslib_1.__importDefault(require_types()); + function default_1(fork) { + var types = fork.use(types_1.default); + var getFieldNames = types.getFieldNames; + var getFieldValue = types.getFieldValue; + var isArray = types.builtInTypes.array; + var isObject = types.builtInTypes.object; + var isDate = types.builtInTypes.Date; + var isRegExp = types.builtInTypes.RegExp; + var hasOwn = Object.prototype.hasOwnProperty; + function astNodesAreEquivalent(a, b, problemPath) { + if (isArray.check(problemPath)) { + problemPath.length = 0; + } else { + problemPath = null; + } + return areEquivalent(a, b, problemPath); + } + astNodesAreEquivalent.assert = function(a, b) { + var problemPath = []; + if (!astNodesAreEquivalent(a, b, problemPath)) { + if (problemPath.length === 0) { + if (a !== b) { + throw new Error("Nodes must be equal"); + } + } else { + throw new Error("Nodes differ in the following path: " + problemPath.map(subscriptForProperty).join("")); + } + } + }; + function subscriptForProperty(property) { + if (/[_$a-z][_$a-z0-9]*/i.test(property)) { + return "." + property; + } + return "[" + JSON.stringify(property) + "]"; + } + function areEquivalent(a, b, problemPath) { + if (a === b) { + return true; + } + if (isArray.check(a)) { + return arraysAreEquivalent(a, b, problemPath); + } + if (isObject.check(a)) { + return objectsAreEquivalent(a, b, problemPath); + } + if (isDate.check(a)) { + return isDate.check(b) && +a === +b; + } + if (isRegExp.check(a)) { + return isRegExp.check(b) && (a.source === b.source && a.global === b.global && a.multiline === b.multiline && a.ignoreCase === b.ignoreCase); + } + return a == b; + } + function arraysAreEquivalent(a, b, problemPath) { + isArray.assert(a); + var aLength = a.length; + if (!isArray.check(b) || b.length !== aLength) { + if (problemPath) { + problemPath.push("length"); + } + return false; + } + for (var i = 0; i < aLength; ++i) { + if (problemPath) { + problemPath.push(i); + } + if (i in a !== i in b) { + return false; + } + if (!areEquivalent(a[i], b[i], problemPath)) { + return false; + } + if (problemPath) { + var problemPathTail = problemPath.pop(); + if (problemPathTail !== i) { + throw new Error("" + problemPathTail); + } + } + } + return true; + } + function objectsAreEquivalent(a, b, problemPath) { + isObject.assert(a); + if (!isObject.check(b)) { + return false; + } + if (a.type !== b.type) { + if (problemPath) { + problemPath.push("type"); + } + return false; + } + var aNames = getFieldNames(a); + var aNameCount = aNames.length; + var bNames = getFieldNames(b); + var bNameCount = bNames.length; + if (aNameCount === bNameCount) { + for (var i = 0; i < aNameCount; ++i) { + var name = aNames[i]; + var aChild = getFieldValue(a, name); + var bChild = getFieldValue(b, name); + if (problemPath) { + problemPath.push(name); + } + if (!areEquivalent(aChild, bChild, problemPath)) { + return false; + } + if (problemPath) { + var problemPathTail = problemPath.pop(); + if (problemPathTail !== name) { + throw new Error("" + problemPathTail); + } + } + } + return true; + } + if (!problemPath) { + return false; + } + var seenNames = /* @__PURE__ */ Object.create(null); + for (i = 0; i < aNameCount; ++i) { + seenNames[aNames[i]] = true; + } + for (i = 0; i < bNameCount; ++i) { + name = bNames[i]; + if (!hasOwn.call(seenNames, name)) { + problemPath.push(name); + return false; + } + delete seenNames[name]; + } + for (name in seenNames) { + problemPath.push(name); + break; + } + return false; + } + return astNodesAreEquivalent; + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/fork.js +var require_fork = __commonJS({ + "../testeranto/node_modules/ast-types/fork.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var types_1 = tslib_1.__importDefault(require_types()); + var path_visitor_1 = tslib_1.__importDefault(require_path_visitor()); + var equiv_1 = tslib_1.__importDefault(require_equiv()); + var path_1 = tslib_1.__importDefault(require_path()); + var node_path_1 = tslib_1.__importDefault(require_node_path()); + function default_1(defs) { + var fork = createFork(); + var types = fork.use(types_1.default); + defs.forEach(fork.use); + types.finalize(); + var PathVisitor = fork.use(path_visitor_1.default); + return { + Type: types.Type, + builtInTypes: types.builtInTypes, + namedTypes: types.namedTypes, + builders: types.builders, + defineMethod: types.defineMethod, + getFieldNames: types.getFieldNames, + getFieldValue: types.getFieldValue, + eachField: types.eachField, + someField: types.someField, + getSupertypeNames: types.getSupertypeNames, + getBuilderName: types.getBuilderName, + astNodesAreEquivalent: fork.use(equiv_1.default), + finalize: types.finalize, + Path: fork.use(path_1.default), + NodePath: fork.use(node_path_1.default), + PathVisitor, + use: fork.use, + visit: PathVisitor.visit + }; + } + exports.default = default_1; + function createFork() { + var used = []; + var usedResult = []; + function use2(plugin) { + var idx = used.indexOf(plugin); + if (idx === -1) { + idx = used.length; + used.push(plugin); + usedResult[idx] = plugin(fork); + } + return usedResult[idx]; + } + var fork = { use: use2 }; + return fork; + } + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/lib/shared.js +var require_shared = __commonJS({ + "../testeranto/node_modules/ast-types/lib/shared.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var types_1 = tslib_1.__importDefault(require_types()); + function default_1(fork) { + var types = fork.use(types_1.default); + var Type = types.Type; + var builtin = types.builtInTypes; + var isNumber = builtin.number; + function geq(than) { + return Type.from(function(value) { + return isNumber.check(value) && value >= than; + }, isNumber + " >= " + than); + } + ; + var defaults = { + // Functions were used because (among other reasons) that's the most + // elegant way to allow for the emptyArray one always to give a new + // array instance. + "null": function() { + return null; + }, + "emptyArray": function() { + return []; + }, + "false": function() { + return false; + }, + "true": function() { + return true; + }, + "undefined": function() { + }, + "use strict": function() { + return "use strict"; + } + }; + var naiveIsPrimitive = Type.or(builtin.string, builtin.number, builtin.boolean, builtin.null, builtin.undefined); + var isPrimitive = Type.from(function(value) { + if (value === null) + return true; + var type = typeof value; + if (type === "object" || type === "function") { + return false; + } + return true; + }, naiveIsPrimitive.toString()); + return { + geq, + defaults, + isPrimitive + }; + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/core.js +var require_core = __commonJS({ + "../testeranto/node_modules/ast-types/def/core.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var types_1 = tslib_1.__importDefault(require_types()); + var shared_1 = tslib_1.__importDefault(require_shared()); + function default_1(fork) { + var types = fork.use(types_1.default); + var Type = types.Type; + var def = Type.def; + var or = Type.or; + var shared = fork.use(shared_1.default); + var defaults = shared.defaults; + var geq = shared.geq; + def("Printable").field("loc", or(def("SourceLocation"), null), defaults["null"], true); + def("Node").bases("Printable").field("type", String).field("comments", or([def("Comment")], null), defaults["null"], true); + def("SourceLocation").field("start", def("Position")).field("end", def("Position")).field("source", or(String, null), defaults["null"]); + def("Position").field("line", geq(1)).field("column", geq(0)); + def("File").bases("Node").build("program", "name").field("program", def("Program")).field("name", or(String, null), defaults["null"]); + def("Program").bases("Node").build("body").field("body", [def("Statement")]); + def("Function").bases("Node").field("id", or(def("Identifier"), null), defaults["null"]).field("params", [def("Pattern")]).field("body", def("BlockStatement")).field("generator", Boolean, defaults["false"]).field("async", Boolean, defaults["false"]); + def("Statement").bases("Node"); + def("EmptyStatement").bases("Statement").build(); + def("BlockStatement").bases("Statement").build("body").field("body", [def("Statement")]); + def("ExpressionStatement").bases("Statement").build("expression").field("expression", def("Expression")); + def("IfStatement").bases("Statement").build("test", "consequent", "alternate").field("test", def("Expression")).field("consequent", def("Statement")).field("alternate", or(def("Statement"), null), defaults["null"]); + def("LabeledStatement").bases("Statement").build("label", "body").field("label", def("Identifier")).field("body", def("Statement")); + def("BreakStatement").bases("Statement").build("label").field("label", or(def("Identifier"), null), defaults["null"]); + def("ContinueStatement").bases("Statement").build("label").field("label", or(def("Identifier"), null), defaults["null"]); + def("WithStatement").bases("Statement").build("object", "body").field("object", def("Expression")).field("body", def("Statement")); + def("SwitchStatement").bases("Statement").build("discriminant", "cases", "lexical").field("discriminant", def("Expression")).field("cases", [def("SwitchCase")]).field("lexical", Boolean, defaults["false"]); + def("ReturnStatement").bases("Statement").build("argument").field("argument", or(def("Expression"), null)); + def("ThrowStatement").bases("Statement").build("argument").field("argument", def("Expression")); + def("TryStatement").bases("Statement").build("block", "handler", "finalizer").field("block", def("BlockStatement")).field("handler", or(def("CatchClause"), null), function() { + return this.handlers && this.handlers[0] || null; + }).field("handlers", [def("CatchClause")], function() { + return this.handler ? [this.handler] : []; + }, true).field("guardedHandlers", [def("CatchClause")], defaults.emptyArray).field("finalizer", or(def("BlockStatement"), null), defaults["null"]); + def("CatchClause").bases("Node").build("param", "guard", "body").field("param", or(def("Pattern"), null), defaults["null"]).field("guard", or(def("Expression"), null), defaults["null"]).field("body", def("BlockStatement")); + def("WhileStatement").bases("Statement").build("test", "body").field("test", def("Expression")).field("body", def("Statement")); + def("DoWhileStatement").bases("Statement").build("body", "test").field("body", def("Statement")).field("test", def("Expression")); + def("ForStatement").bases("Statement").build("init", "test", "update", "body").field("init", or(def("VariableDeclaration"), def("Expression"), null)).field("test", or(def("Expression"), null)).field("update", or(def("Expression"), null)).field("body", def("Statement")); + def("ForInStatement").bases("Statement").build("left", "right", "body").field("left", or(def("VariableDeclaration"), def("Expression"))).field("right", def("Expression")).field("body", def("Statement")); + def("DebuggerStatement").bases("Statement").build(); + def("Declaration").bases("Statement"); + def("FunctionDeclaration").bases("Function", "Declaration").build("id", "params", "body").field("id", def("Identifier")); + def("FunctionExpression").bases("Function", "Expression").build("id", "params", "body"); + def("VariableDeclaration").bases("Declaration").build("kind", "declarations").field("kind", or("var", "let", "const")).field("declarations", [def("VariableDeclarator")]); + def("VariableDeclarator").bases("Node").build("id", "init").field("id", def("Pattern")).field("init", or(def("Expression"), null), defaults["null"]); + def("Expression").bases("Node"); + def("ThisExpression").bases("Expression").build(); + def("ArrayExpression").bases("Expression").build("elements").field("elements", [or(def("Expression"), null)]); + def("ObjectExpression").bases("Expression").build("properties").field("properties", [def("Property")]); + def("Property").bases("Node").build("kind", "key", "value").field("kind", or("init", "get", "set")).field("key", or(def("Literal"), def("Identifier"))).field("value", def("Expression")); + def("SequenceExpression").bases("Expression").build("expressions").field("expressions", [def("Expression")]); + var UnaryOperator = or("-", "+", "!", "~", "typeof", "void", "delete"); + def("UnaryExpression").bases("Expression").build("operator", "argument", "prefix").field("operator", UnaryOperator).field("argument", def("Expression")).field("prefix", Boolean, defaults["true"]); + var BinaryOperator = or( + "==", + "!=", + "===", + "!==", + "<", + "<=", + ">", + ">=", + "<<", + ">>", + ">>>", + "+", + "-", + "*", + "/", + "%", + "**", + "&", + // TODO Missing from the Parser API. + "|", + "^", + "in", + "instanceof" + ); + def("BinaryExpression").bases("Expression").build("operator", "left", "right").field("operator", BinaryOperator).field("left", def("Expression")).field("right", def("Expression")); + var AssignmentOperator = or("=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "^=", "&="); + def("AssignmentExpression").bases("Expression").build("operator", "left", "right").field("operator", AssignmentOperator).field("left", or(def("Pattern"), def("MemberExpression"))).field("right", def("Expression")); + var UpdateOperator = or("++", "--"); + def("UpdateExpression").bases("Expression").build("operator", "argument", "prefix").field("operator", UpdateOperator).field("argument", def("Expression")).field("prefix", Boolean); + var LogicalOperator = or("||", "&&"); + def("LogicalExpression").bases("Expression").build("operator", "left", "right").field("operator", LogicalOperator).field("left", def("Expression")).field("right", def("Expression")); + def("ConditionalExpression").bases("Expression").build("test", "consequent", "alternate").field("test", def("Expression")).field("consequent", def("Expression")).field("alternate", def("Expression")); + def("NewExpression").bases("Expression").build("callee", "arguments").field("callee", def("Expression")).field("arguments", [def("Expression")]); + def("CallExpression").bases("Expression").build("callee", "arguments").field("callee", def("Expression")).field("arguments", [def("Expression")]); + def("MemberExpression").bases("Expression").build("object", "property", "computed").field("object", def("Expression")).field("property", or(def("Identifier"), def("Expression"))).field("computed", Boolean, function() { + var type = this.property.type; + if (type === "Literal" || type === "MemberExpression" || type === "BinaryExpression") { + return true; + } + return false; + }); + def("Pattern").bases("Node"); + def("SwitchCase").bases("Node").build("test", "consequent").field("test", or(def("Expression"), null)).field("consequent", [def("Statement")]); + def("Identifier").bases("Expression", "Pattern").build("name").field("name", String).field("optional", Boolean, defaults["false"]); + def("Literal").bases("Expression").build("value").field("value", or(String, Boolean, null, Number, RegExp)).field("regex", or({ + pattern: String, + flags: String + }, null), function() { + if (this.value instanceof RegExp) { + var flags = ""; + if (this.value.ignoreCase) + flags += "i"; + if (this.value.multiline) + flags += "m"; + if (this.value.global) + flags += "g"; + return { + pattern: this.value.source, + flags + }; + } + return null; + }); + def("Comment").bases("Printable").field("value", String).field("leading", Boolean, defaults["true"]).field("trailing", Boolean, defaults["false"]); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/es6.js +var require_es6 = __commonJS({ + "../testeranto/node_modules/ast-types/def/es6.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var core_1 = tslib_1.__importDefault(require_core()); + var types_1 = tslib_1.__importDefault(require_types()); + var shared_1 = tslib_1.__importDefault(require_shared()); + function default_1(fork) { + fork.use(core_1.default); + var types = fork.use(types_1.default); + var def = types.Type.def; + var or = types.Type.or; + var defaults = fork.use(shared_1.default).defaults; + def("Function").field("generator", Boolean, defaults["false"]).field("expression", Boolean, defaults["false"]).field("defaults", [or(def("Expression"), null)], defaults.emptyArray).field("rest", or(def("Identifier"), null), defaults["null"]); + def("RestElement").bases("Pattern").build("argument").field("argument", def("Pattern")).field( + "typeAnnotation", + // for Babylon. Flow parser puts it on the identifier + or(def("TypeAnnotation"), def("TSTypeAnnotation"), null), + defaults["null"] + ); + def("SpreadElementPattern").bases("Pattern").build("argument").field("argument", def("Pattern")); + def("FunctionDeclaration").build("id", "params", "body", "generator", "expression"); + def("FunctionExpression").build("id", "params", "body", "generator", "expression"); + def("ArrowFunctionExpression").bases("Function", "Expression").build("params", "body", "expression").field("id", null, defaults["null"]).field("body", or(def("BlockStatement"), def("Expression"))).field("generator", false, defaults["false"]); + def("ForOfStatement").bases("Statement").build("left", "right", "body").field("left", or(def("VariableDeclaration"), def("Pattern"))).field("right", def("Expression")).field("body", def("Statement")); + def("YieldExpression").bases("Expression").build("argument", "delegate").field("argument", or(def("Expression"), null)).field("delegate", Boolean, defaults["false"]); + def("GeneratorExpression").bases("Expression").build("body", "blocks", "filter").field("body", def("Expression")).field("blocks", [def("ComprehensionBlock")]).field("filter", or(def("Expression"), null)); + def("ComprehensionExpression").bases("Expression").build("body", "blocks", "filter").field("body", def("Expression")).field("blocks", [def("ComprehensionBlock")]).field("filter", or(def("Expression"), null)); + def("ComprehensionBlock").bases("Node").build("left", "right", "each").field("left", def("Pattern")).field("right", def("Expression")).field("each", Boolean); + def("Property").field("key", or(def("Literal"), def("Identifier"), def("Expression"))).field("value", or(def("Expression"), def("Pattern"))).field("method", Boolean, defaults["false"]).field("shorthand", Boolean, defaults["false"]).field("computed", Boolean, defaults["false"]); + def("ObjectProperty").field("shorthand", Boolean, defaults["false"]); + def("PropertyPattern").bases("Pattern").build("key", "pattern").field("key", or(def("Literal"), def("Identifier"), def("Expression"))).field("pattern", def("Pattern")).field("computed", Boolean, defaults["false"]); + def("ObjectPattern").bases("Pattern").build("properties").field("properties", [or(def("PropertyPattern"), def("Property"))]); + def("ArrayPattern").bases("Pattern").build("elements").field("elements", [or(def("Pattern"), null)]); + def("MethodDefinition").bases("Declaration").build("kind", "key", "value", "static").field("kind", or("constructor", "method", "get", "set")).field("key", def("Expression")).field("value", def("Function")).field("computed", Boolean, defaults["false"]).field("static", Boolean, defaults["false"]); + def("SpreadElement").bases("Node").build("argument").field("argument", def("Expression")); + def("ArrayExpression").field("elements", [or(def("Expression"), def("SpreadElement"), def("RestElement"), null)]); + def("NewExpression").field("arguments", [or(def("Expression"), def("SpreadElement"))]); + def("CallExpression").field("arguments", [or(def("Expression"), def("SpreadElement"))]); + def("AssignmentPattern").bases("Pattern").build("left", "right").field("left", def("Pattern")).field("right", def("Expression")); + var ClassBodyElement = or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty")); + def("ClassProperty").bases("Declaration").build("key").field("key", or(def("Literal"), def("Identifier"), def("Expression"))).field("computed", Boolean, defaults["false"]); + def("ClassPropertyDefinition").bases("Declaration").build("definition").field("definition", ClassBodyElement); + def("ClassBody").bases("Declaration").build("body").field("body", [ClassBodyElement]); + def("ClassDeclaration").bases("Declaration").build("id", "body", "superClass").field("id", or(def("Identifier"), null)).field("body", def("ClassBody")).field("superClass", or(def("Expression"), null), defaults["null"]); + def("ClassExpression").bases("Expression").build("id", "body", "superClass").field("id", or(def("Identifier"), null), defaults["null"]).field("body", def("ClassBody")).field("superClass", or(def("Expression"), null), defaults["null"]); + def("Specifier").bases("Node"); + def("ModuleSpecifier").bases("Specifier").field("local", or(def("Identifier"), null), defaults["null"]).field("id", or(def("Identifier"), null), defaults["null"]).field("name", or(def("Identifier"), null), defaults["null"]); + def("ImportSpecifier").bases("ModuleSpecifier").build("id", "name"); + def("ImportNamespaceSpecifier").bases("ModuleSpecifier").build("id"); + def("ImportDefaultSpecifier").bases("ModuleSpecifier").build("id"); + def("ImportDeclaration").bases("Declaration").build("specifiers", "source", "importKind").field("specifiers", [or(def("ImportSpecifier"), def("ImportNamespaceSpecifier"), def("ImportDefaultSpecifier"))], defaults.emptyArray).field("source", def("Literal")).field("importKind", or("value", "type"), function() { + return "value"; + }); + def("TaggedTemplateExpression").bases("Expression").build("tag", "quasi").field("tag", def("Expression")).field("quasi", def("TemplateLiteral")); + def("TemplateLiteral").bases("Expression").build("quasis", "expressions").field("quasis", [def("TemplateElement")]).field("expressions", [def("Expression")]); + def("TemplateElement").bases("Node").build("value", "tail").field("value", { "cooked": String, "raw": String }).field("tail", Boolean); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/es7.js +var require_es7 = __commonJS({ + "../testeranto/node_modules/ast-types/def/es7.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var es6_1 = tslib_1.__importDefault(require_es6()); + var types_1 = tslib_1.__importDefault(require_types()); + var shared_1 = tslib_1.__importDefault(require_shared()); + function default_1(fork) { + fork.use(es6_1.default); + var types = fork.use(types_1.default); + var def = types.Type.def; + var or = types.Type.or; + var defaults = fork.use(shared_1.default).defaults; + def("Function").field("async", Boolean, defaults["false"]); + def("SpreadProperty").bases("Node").build("argument").field("argument", def("Expression")); + def("ObjectExpression").field("properties", [or(def("Property"), def("SpreadProperty"), def("SpreadElement"))]); + def("SpreadPropertyPattern").bases("Pattern").build("argument").field("argument", def("Pattern")); + def("ObjectPattern").field("properties", [or(def("Property"), def("PropertyPattern"), def("SpreadPropertyPattern"))]); + def("AwaitExpression").bases("Expression").build("argument", "all").field("argument", or(def("Expression"), null)).field("all", Boolean, defaults["false"]); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/es2020.js +var require_es2020 = __commonJS({ + "../testeranto/node_modules/ast-types/def/es2020.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var es7_1 = tslib_1.__importDefault(require_es7()); + var types_1 = tslib_1.__importDefault(require_types()); + function default_1(fork) { + fork.use(es7_1.default); + var types = fork.use(types_1.default); + var def = types.Type.def; + def("ImportExpression").bases("Expression").build("source").field("source", def("Expression")); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/jsx.js +var require_jsx = __commonJS({ + "../testeranto/node_modules/ast-types/def/jsx.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var es7_1 = tslib_1.__importDefault(require_es7()); + var types_1 = tslib_1.__importDefault(require_types()); + var shared_1 = tslib_1.__importDefault(require_shared()); + function default_1(fork) { + fork.use(es7_1.default); + var types = fork.use(types_1.default); + var def = types.Type.def; + var or = types.Type.or; + var defaults = fork.use(shared_1.default).defaults; + def("JSXAttribute").bases("Node").build("name", "value").field("name", or(def("JSXIdentifier"), def("JSXNamespacedName"))).field("value", or( + def("Literal"), + // attr="value" + def("JSXExpressionContainer"), + // attr={value} + null + // attr= or just attr + ), defaults["null"]); + def("JSXIdentifier").bases("Identifier").build("name").field("name", String); + def("JSXNamespacedName").bases("Node").build("namespace", "name").field("namespace", def("JSXIdentifier")).field("name", def("JSXIdentifier")); + def("JSXMemberExpression").bases("MemberExpression").build("object", "property").field("object", or(def("JSXIdentifier"), def("JSXMemberExpression"))).field("property", def("JSXIdentifier")).field("computed", Boolean, defaults.false); + var JSXElementName = or(def("JSXIdentifier"), def("JSXNamespacedName"), def("JSXMemberExpression")); + def("JSXSpreadAttribute").bases("Node").build("argument").field("argument", def("Expression")); + var JSXAttributes = [or(def("JSXAttribute"), def("JSXSpreadAttribute"))]; + def("JSXExpressionContainer").bases("Expression").build("expression").field("expression", def("Expression")); + def("JSXElement").bases("Expression").build("openingElement", "closingElement", "children").field("openingElement", def("JSXOpeningElement")).field("closingElement", or(def("JSXClosingElement"), null), defaults["null"]).field("children", [or( + def("JSXElement"), + def("JSXExpressionContainer"), + def("JSXFragment"), + def("JSXText"), + def("Literal") + // TODO Esprima should return JSXText instead. + )], defaults.emptyArray).field("name", JSXElementName, function() { + return this.openingElement.name; + }, true).field("selfClosing", Boolean, function() { + return this.openingElement.selfClosing; + }, true).field("attributes", JSXAttributes, function() { + return this.openingElement.attributes; + }, true); + def("JSXOpeningElement").bases("Node").build("name", "attributes", "selfClosing").field("name", JSXElementName).field("attributes", JSXAttributes, defaults.emptyArray).field("selfClosing", Boolean, defaults["false"]); + def("JSXClosingElement").bases("Node").build("name").field("name", JSXElementName); + def("JSXFragment").bases("Expression").build("openingElement", "closingElement", "children").field("openingElement", def("JSXOpeningFragment")).field("closingElement", def("JSXClosingFragment")).field("children", [or( + def("JSXElement"), + def("JSXExpressionContainer"), + def("JSXFragment"), + def("JSXText"), + def("Literal") + // TODO Esprima should return JSXText instead. + )], defaults.emptyArray); + def("JSXOpeningFragment").bases("Node").build(); + def("JSXClosingFragment").bases("Node").build(); + def("JSXText").bases("Literal").build("value").field("value", String); + def("JSXEmptyExpression").bases("Expression").build(); + def("JSXSpreadChild").bases("Expression").build("expression").field("expression", def("Expression")); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/type-annotations.js +var require_type_annotations = __commonJS({ + "../testeranto/node_modules/ast-types/def/type-annotations.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var types_1 = tslib_1.__importDefault(require_types()); + var shared_1 = tslib_1.__importDefault(require_shared()); + function default_1(fork) { + var types = fork.use(types_1.default); + var def = types.Type.def; + var or = types.Type.or; + var defaults = fork.use(shared_1.default).defaults; + var TypeAnnotation = or(def("TypeAnnotation"), def("TSTypeAnnotation"), null); + var TypeParamDecl = or(def("TypeParameterDeclaration"), def("TSTypeParameterDeclaration"), null); + def("Identifier").field("typeAnnotation", TypeAnnotation, defaults["null"]); + def("ObjectPattern").field("typeAnnotation", TypeAnnotation, defaults["null"]); + def("Function").field("returnType", TypeAnnotation, defaults["null"]).field("typeParameters", TypeParamDecl, defaults["null"]); + def("ClassProperty").build("key", "value", "typeAnnotation", "static").field("value", or(def("Expression"), null)).field("static", Boolean, defaults["false"]).field("typeAnnotation", TypeAnnotation, defaults["null"]); + [ + "ClassDeclaration", + "ClassExpression" + ].forEach(function(typeName) { + def(typeName).field("typeParameters", TypeParamDecl, defaults["null"]).field("superTypeParameters", or(def("TypeParameterInstantiation"), def("TSTypeParameterInstantiation"), null), defaults["null"]).field("implements", or([def("ClassImplements")], [def("TSExpressionWithTypeArguments")]), defaults.emptyArray); + }); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/flow.js +var require_flow = __commonJS({ + "../testeranto/node_modules/ast-types/def/flow.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var es7_1 = tslib_1.__importDefault(require_es7()); + var type_annotations_1 = tslib_1.__importDefault(require_type_annotations()); + var types_1 = tslib_1.__importDefault(require_types()); + var shared_1 = tslib_1.__importDefault(require_shared()); + function default_1(fork) { + fork.use(es7_1.default); + fork.use(type_annotations_1.default); + var types = fork.use(types_1.default); + var def = types.Type.def; + var or = types.Type.or; + var defaults = fork.use(shared_1.default).defaults; + def("Flow").bases("Node"); + def("FlowType").bases("Flow"); + def("AnyTypeAnnotation").bases("FlowType").build(); + def("EmptyTypeAnnotation").bases("FlowType").build(); + def("MixedTypeAnnotation").bases("FlowType").build(); + def("VoidTypeAnnotation").bases("FlowType").build(); + def("NumberTypeAnnotation").bases("FlowType").build(); + def("NumberLiteralTypeAnnotation").bases("FlowType").build("value", "raw").field("value", Number).field("raw", String); + def("NumericLiteralTypeAnnotation").bases("FlowType").build("value", "raw").field("value", Number).field("raw", String); + def("StringTypeAnnotation").bases("FlowType").build(); + def("StringLiteralTypeAnnotation").bases("FlowType").build("value", "raw").field("value", String).field("raw", String); + def("BooleanTypeAnnotation").bases("FlowType").build(); + def("BooleanLiteralTypeAnnotation").bases("FlowType").build("value", "raw").field("value", Boolean).field("raw", String); + def("TypeAnnotation").bases("Node").build("typeAnnotation").field("typeAnnotation", def("FlowType")); + def("NullableTypeAnnotation").bases("FlowType").build("typeAnnotation").field("typeAnnotation", def("FlowType")); + def("NullLiteralTypeAnnotation").bases("FlowType").build(); + def("NullTypeAnnotation").bases("FlowType").build(); + def("ThisTypeAnnotation").bases("FlowType").build(); + def("ExistsTypeAnnotation").bases("FlowType").build(); + def("ExistentialTypeParam").bases("FlowType").build(); + def("FunctionTypeAnnotation").bases("FlowType").build("params", "returnType", "rest", "typeParameters").field("params", [def("FunctionTypeParam")]).field("returnType", def("FlowType")).field("rest", or(def("FunctionTypeParam"), null)).field("typeParameters", or(def("TypeParameterDeclaration"), null)); + def("FunctionTypeParam").bases("Node").build("name", "typeAnnotation", "optional").field("name", def("Identifier")).field("typeAnnotation", def("FlowType")).field("optional", Boolean); + def("ArrayTypeAnnotation").bases("FlowType").build("elementType").field("elementType", def("FlowType")); + def("ObjectTypeAnnotation").bases("FlowType").build("properties", "indexers", "callProperties").field("properties", [ + or(def("ObjectTypeProperty"), def("ObjectTypeSpreadProperty")) + ]).field("indexers", [def("ObjectTypeIndexer")], defaults.emptyArray).field("callProperties", [def("ObjectTypeCallProperty")], defaults.emptyArray).field("inexact", or(Boolean, void 0), defaults["undefined"]).field("exact", Boolean, defaults["false"]).field("internalSlots", [def("ObjectTypeInternalSlot")], defaults.emptyArray); + def("Variance").bases("Node").build("kind").field("kind", or("plus", "minus")); + var LegacyVariance = or(def("Variance"), "plus", "minus", null); + def("ObjectTypeProperty").bases("Node").build("key", "value", "optional").field("key", or(def("Literal"), def("Identifier"))).field("value", def("FlowType")).field("optional", Boolean).field("variance", LegacyVariance, defaults["null"]); + def("ObjectTypeIndexer").bases("Node").build("id", "key", "value").field("id", def("Identifier")).field("key", def("FlowType")).field("value", def("FlowType")).field("variance", LegacyVariance, defaults["null"]); + def("ObjectTypeCallProperty").bases("Node").build("value").field("value", def("FunctionTypeAnnotation")).field("static", Boolean, defaults["false"]); + def("QualifiedTypeIdentifier").bases("Node").build("qualification", "id").field("qualification", or(def("Identifier"), def("QualifiedTypeIdentifier"))).field("id", def("Identifier")); + def("GenericTypeAnnotation").bases("FlowType").build("id", "typeParameters").field("id", or(def("Identifier"), def("QualifiedTypeIdentifier"))).field("typeParameters", or(def("TypeParameterInstantiation"), null)); + def("MemberTypeAnnotation").bases("FlowType").build("object", "property").field("object", def("Identifier")).field("property", or(def("MemberTypeAnnotation"), def("GenericTypeAnnotation"))); + def("UnionTypeAnnotation").bases("FlowType").build("types").field("types", [def("FlowType")]); + def("IntersectionTypeAnnotation").bases("FlowType").build("types").field("types", [def("FlowType")]); + def("TypeofTypeAnnotation").bases("FlowType").build("argument").field("argument", def("FlowType")); + def("ObjectTypeSpreadProperty").bases("Node").build("argument").field("argument", def("FlowType")); + def("ObjectTypeInternalSlot").bases("Node").build("id", "value", "optional", "static", "method").field("id", def("Identifier")).field("value", def("FlowType")).field("optional", Boolean).field("static", Boolean).field("method", Boolean); + def("TypeParameterDeclaration").bases("Node").build("params").field("params", [def("TypeParameter")]); + def("TypeParameterInstantiation").bases("Node").build("params").field("params", [def("FlowType")]); + def("TypeParameter").bases("FlowType").build("name", "variance", "bound").field("name", String).field("variance", LegacyVariance, defaults["null"]).field("bound", or(def("TypeAnnotation"), null), defaults["null"]); + def("ClassProperty").field("variance", LegacyVariance, defaults["null"]); + def("ClassImplements").bases("Node").build("id").field("id", def("Identifier")).field("superClass", or(def("Expression"), null), defaults["null"]).field("typeParameters", or(def("TypeParameterInstantiation"), null), defaults["null"]); + def("InterfaceTypeAnnotation").bases("FlowType").build("body", "extends").field("body", def("ObjectTypeAnnotation")).field("extends", or([def("InterfaceExtends")], null), defaults["null"]); + def("InterfaceDeclaration").bases("Declaration").build("id", "body", "extends").field("id", def("Identifier")).field("typeParameters", or(def("TypeParameterDeclaration"), null), defaults["null"]).field("body", def("ObjectTypeAnnotation")).field("extends", [def("InterfaceExtends")]); + def("DeclareInterface").bases("InterfaceDeclaration").build("id", "body", "extends"); + def("InterfaceExtends").bases("Node").build("id").field("id", def("Identifier")).field("typeParameters", or(def("TypeParameterInstantiation"), null), defaults["null"]); + def("TypeAlias").bases("Declaration").build("id", "typeParameters", "right").field("id", def("Identifier")).field("typeParameters", or(def("TypeParameterDeclaration"), null)).field("right", def("FlowType")); + def("OpaqueType").bases("Declaration").build("id", "typeParameters", "impltype", "supertype").field("id", def("Identifier")).field("typeParameters", or(def("TypeParameterDeclaration"), null)).field("impltype", def("FlowType")).field("supertype", def("FlowType")); + def("DeclareTypeAlias").bases("TypeAlias").build("id", "typeParameters", "right"); + def("DeclareOpaqueType").bases("TypeAlias").build("id", "typeParameters", "supertype"); + def("TypeCastExpression").bases("Expression").build("expression", "typeAnnotation").field("expression", def("Expression")).field("typeAnnotation", def("TypeAnnotation")); + def("TupleTypeAnnotation").bases("FlowType").build("types").field("types", [def("FlowType")]); + def("DeclareVariable").bases("Statement").build("id").field("id", def("Identifier")); + def("DeclareFunction").bases("Statement").build("id").field("id", def("Identifier")); + def("DeclareClass").bases("InterfaceDeclaration").build("id"); + def("DeclareModule").bases("Statement").build("id", "body").field("id", or(def("Identifier"), def("Literal"))).field("body", def("BlockStatement")); + def("DeclareModuleExports").bases("Statement").build("typeAnnotation").field("typeAnnotation", def("TypeAnnotation")); + def("DeclareExportDeclaration").bases("Declaration").build("default", "declaration", "specifiers", "source").field("default", Boolean).field("declaration", or( + def("DeclareVariable"), + def("DeclareFunction"), + def("DeclareClass"), + def("FlowType"), + // Implies default. + null + )).field("specifiers", [or(def("ExportSpecifier"), def("ExportBatchSpecifier"))], defaults.emptyArray).field("source", or(def("Literal"), null), defaults["null"]); + def("DeclareExportAllDeclaration").bases("Declaration").build("source").field("source", or(def("Literal"), null), defaults["null"]); + def("FlowPredicate").bases("Flow"); + def("InferredPredicate").bases("FlowPredicate").build(); + def("DeclaredPredicate").bases("FlowPredicate").build("value").field("value", def("Expression")); + def("CallExpression").field("typeArguments", or(null, def("TypeParameterInstantiation")), defaults["null"]); + def("NewExpression").field("typeArguments", or(null, def("TypeParameterInstantiation")), defaults["null"]); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/esprima.js +var require_esprima2 = __commonJS({ + "../testeranto/node_modules/ast-types/def/esprima.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var es7_1 = tslib_1.__importDefault(require_es7()); + var types_1 = tslib_1.__importDefault(require_types()); + var shared_1 = tslib_1.__importDefault(require_shared()); + function default_1(fork) { + fork.use(es7_1.default); + var types = fork.use(types_1.default); + var defaults = fork.use(shared_1.default).defaults; + var def = types.Type.def; + var or = types.Type.or; + def("VariableDeclaration").field("declarations", [or( + def("VariableDeclarator"), + def("Identifier") + // Esprima deviation. + )]); + def("Property").field("value", or( + def("Expression"), + def("Pattern") + // Esprima deviation. + )); + def("ArrayPattern").field("elements", [or(def("Pattern"), def("SpreadElement"), null)]); + def("ObjectPattern").field("properties", [or( + def("Property"), + def("PropertyPattern"), + def("SpreadPropertyPattern"), + def("SpreadProperty") + // Used by Esprima. + )]); + def("ExportSpecifier").bases("ModuleSpecifier").build("id", "name"); + def("ExportBatchSpecifier").bases("Specifier").build(); + def("ExportDeclaration").bases("Declaration").build("default", "declaration", "specifiers", "source").field("default", Boolean).field("declaration", or( + def("Declaration"), + def("Expression"), + // Implies default. + null + )).field("specifiers", [or(def("ExportSpecifier"), def("ExportBatchSpecifier"))], defaults.emptyArray).field("source", or(def("Literal"), null), defaults["null"]); + def("Block").bases("Comment").build( + "value", + /*optional:*/ + "leading", + "trailing" + ); + def("Line").bases("Comment").build( + "value", + /*optional:*/ + "leading", + "trailing" + ); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/babel-core.js +var require_babel_core = __commonJS({ + "../testeranto/node_modules/ast-types/def/babel-core.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var types_1 = tslib_1.__importDefault(require_types()); + var shared_1 = tslib_1.__importDefault(require_shared()); + var es7_1 = tslib_1.__importDefault(require_es7()); + function default_1(fork) { + fork.use(es7_1.default); + var types = fork.use(types_1.default); + var defaults = fork.use(shared_1.default).defaults; + var def = types.Type.def; + var or = types.Type.or; + def("Noop").bases("Statement").build(); + def("DoExpression").bases("Expression").build("body").field("body", [def("Statement")]); + def("Super").bases("Expression").build(); + def("BindExpression").bases("Expression").build("object", "callee").field("object", or(def("Expression"), null)).field("callee", def("Expression")); + def("Decorator").bases("Node").build("expression").field("expression", def("Expression")); + def("Property").field("decorators", or([def("Decorator")], null), defaults["null"]); + def("MethodDefinition").field("decorators", or([def("Decorator")], null), defaults["null"]); + def("MetaProperty").bases("Expression").build("meta", "property").field("meta", def("Identifier")).field("property", def("Identifier")); + def("ParenthesizedExpression").bases("Expression").build("expression").field("expression", def("Expression")); + def("ImportSpecifier").bases("ModuleSpecifier").build("imported", "local").field("imported", def("Identifier")); + def("ImportDefaultSpecifier").bases("ModuleSpecifier").build("local"); + def("ImportNamespaceSpecifier").bases("ModuleSpecifier").build("local"); + def("ExportDefaultDeclaration").bases("Declaration").build("declaration").field("declaration", or(def("Declaration"), def("Expression"))); + def("ExportNamedDeclaration").bases("Declaration").build("declaration", "specifiers", "source").field("declaration", or(def("Declaration"), null)).field("specifiers", [def("ExportSpecifier")], defaults.emptyArray).field("source", or(def("Literal"), null), defaults["null"]); + def("ExportSpecifier").bases("ModuleSpecifier").build("local", "exported").field("exported", def("Identifier")); + def("ExportNamespaceSpecifier").bases("Specifier").build("exported").field("exported", def("Identifier")); + def("ExportDefaultSpecifier").bases("Specifier").build("exported").field("exported", def("Identifier")); + def("ExportAllDeclaration").bases("Declaration").build("exported", "source").field("exported", or(def("Identifier"), null)).field("source", def("Literal")); + def("CommentBlock").bases("Comment").build( + "value", + /*optional:*/ + "leading", + "trailing" + ); + def("CommentLine").bases("Comment").build( + "value", + /*optional:*/ + "leading", + "trailing" + ); + def("Directive").bases("Node").build("value").field("value", def("DirectiveLiteral")); + def("DirectiveLiteral").bases("Node", "Expression").build("value").field("value", String, defaults["use strict"]); + def("InterpreterDirective").bases("Node").build("value").field("value", String); + def("BlockStatement").bases("Statement").build("body").field("body", [def("Statement")]).field("directives", [def("Directive")], defaults.emptyArray); + def("Program").bases("Node").build("body").field("body", [def("Statement")]).field("directives", [def("Directive")], defaults.emptyArray).field("interpreter", or(def("InterpreterDirective"), null), defaults["null"]); + def("StringLiteral").bases("Literal").build("value").field("value", String); + def("NumericLiteral").bases("Literal").build("value").field("value", Number).field("raw", or(String, null), defaults["null"]).field("extra", { + rawValue: Number, + raw: String + }, function getDefault() { + return { + rawValue: this.value, + raw: this.value + "" + }; + }); + def("BigIntLiteral").bases("Literal").build("value").field("value", or(String, Number)).field("extra", { + rawValue: String, + raw: String + }, function getDefault() { + return { + rawValue: String(this.value), + raw: this.value + "n" + }; + }); + def("NullLiteral").bases("Literal").build().field("value", null, defaults["null"]); + def("BooleanLiteral").bases("Literal").build("value").field("value", Boolean); + def("RegExpLiteral").bases("Literal").build("pattern", "flags").field("pattern", String).field("flags", String).field("value", RegExp, function() { + return new RegExp(this.pattern, this.flags); + }); + var ObjectExpressionProperty = or(def("Property"), def("ObjectMethod"), def("ObjectProperty"), def("SpreadProperty"), def("SpreadElement")); + def("ObjectExpression").bases("Expression").build("properties").field("properties", [ObjectExpressionProperty]); + def("ObjectMethod").bases("Node", "Function").build("kind", "key", "params", "body", "computed").field("kind", or("method", "get", "set")).field("key", or(def("Literal"), def("Identifier"), def("Expression"))).field("params", [def("Pattern")]).field("body", def("BlockStatement")).field("computed", Boolean, defaults["false"]).field("generator", Boolean, defaults["false"]).field("async", Boolean, defaults["false"]).field( + "accessibility", + // TypeScript + or(def("Literal"), null), + defaults["null"] + ).field("decorators", or([def("Decorator")], null), defaults["null"]); + def("ObjectProperty").bases("Node").build("key", "value").field("key", or(def("Literal"), def("Identifier"), def("Expression"))).field("value", or(def("Expression"), def("Pattern"))).field( + "accessibility", + // TypeScript + or(def("Literal"), null), + defaults["null"] + ).field("computed", Boolean, defaults["false"]); + var ClassBodyElement = or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty"), def("ClassPrivateProperty"), def("ClassMethod"), def("ClassPrivateMethod")); + def("ClassBody").bases("Declaration").build("body").field("body", [ClassBodyElement]); + def("ClassMethod").bases("Declaration", "Function").build("kind", "key", "params", "body", "computed", "static").field("key", or(def("Literal"), def("Identifier"), def("Expression"))); + def("ClassPrivateMethod").bases("Declaration", "Function").build("key", "params", "body", "kind", "computed", "static").field("key", def("PrivateName")); + [ + "ClassMethod", + "ClassPrivateMethod" + ].forEach(function(typeName) { + def(typeName).field("kind", or("get", "set", "method", "constructor"), function() { + return "method"; + }).field("body", def("BlockStatement")).field("computed", Boolean, defaults["false"]).field("static", or(Boolean, null), defaults["null"]).field("abstract", or(Boolean, null), defaults["null"]).field("access", or("public", "private", "protected", null), defaults["null"]).field("accessibility", or("public", "private", "protected", null), defaults["null"]).field("decorators", or([def("Decorator")], null), defaults["null"]).field("optional", or(Boolean, null), defaults["null"]); + }); + def("ClassPrivateProperty").bases("ClassProperty").build("key", "value").field("key", def("PrivateName")).field("value", or(def("Expression"), null), defaults["null"]); + def("PrivateName").bases("Expression", "Pattern").build("id").field("id", def("Identifier")); + var ObjectPatternProperty = or( + def("Property"), + def("PropertyPattern"), + def("SpreadPropertyPattern"), + def("SpreadProperty"), + // Used by Esprima + def("ObjectProperty"), + // Babel 6 + def("RestProperty") + // Babel 6 + ); + def("ObjectPattern").bases("Pattern").build("properties").field("properties", [ObjectPatternProperty]).field("decorators", or([def("Decorator")], null), defaults["null"]); + def("SpreadProperty").bases("Node").build("argument").field("argument", def("Expression")); + def("RestProperty").bases("Node").build("argument").field("argument", def("Expression")); + def("ForAwaitStatement").bases("Statement").build("left", "right", "body").field("left", or(def("VariableDeclaration"), def("Expression"))).field("right", def("Expression")).field("body", def("Statement")); + def("Import").bases("Expression").build(); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/babel.js +var require_babel = __commonJS({ + "../testeranto/node_modules/ast-types/def/babel.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var babel_core_1 = tslib_1.__importDefault(require_babel_core()); + var flow_1 = tslib_1.__importDefault(require_flow()); + function default_1(fork) { + fork.use(babel_core_1.default); + fork.use(flow_1.default); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/typescript.js +var require_typescript = __commonJS({ + "../testeranto/node_modules/ast-types/def/typescript.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var babel_core_1 = tslib_1.__importDefault(require_babel_core()); + var type_annotations_1 = tslib_1.__importDefault(require_type_annotations()); + var types_1 = tslib_1.__importDefault(require_types()); + var shared_1 = tslib_1.__importDefault(require_shared()); + function default_1(fork) { + fork.use(babel_core_1.default); + fork.use(type_annotations_1.default); + var types = fork.use(types_1.default); + var n = types.namedTypes; + var def = types.Type.def; + var or = types.Type.or; + var defaults = fork.use(shared_1.default).defaults; + var StringLiteral = types.Type.from(function(value, deep) { + if (n.StringLiteral && n.StringLiteral.check(value, deep)) { + return true; + } + if (n.Literal && n.Literal.check(value, deep) && typeof value.value === "string") { + return true; + } + return false; + }, "StringLiteral"); + def("TSType").bases("Node"); + var TSEntityName = or(def("Identifier"), def("TSQualifiedName")); + def("TSTypeReference").bases("TSType", "TSHasOptionalTypeParameterInstantiation").build("typeName", "typeParameters").field("typeName", TSEntityName); + def("TSHasOptionalTypeParameterInstantiation").field("typeParameters", or(def("TSTypeParameterInstantiation"), null), defaults["null"]); + def("TSHasOptionalTypeParameters").field("typeParameters", or(def("TSTypeParameterDeclaration"), null, void 0), defaults["null"]); + def("TSHasOptionalTypeAnnotation").field("typeAnnotation", or(def("TSTypeAnnotation"), null), defaults["null"]); + def("TSQualifiedName").bases("Node").build("left", "right").field("left", TSEntityName).field("right", TSEntityName); + def("TSAsExpression").bases("Expression", "Pattern").build("expression", "typeAnnotation").field("expression", def("Expression")).field("typeAnnotation", def("TSType")).field("extra", or({ parenthesized: Boolean }, null), defaults["null"]); + def("TSNonNullExpression").bases("Expression", "Pattern").build("expression").field("expression", def("Expression")); + [ + "TSAnyKeyword", + "TSBigIntKeyword", + "TSBooleanKeyword", + "TSNeverKeyword", + "TSNullKeyword", + "TSNumberKeyword", + "TSObjectKeyword", + "TSStringKeyword", + "TSSymbolKeyword", + "TSUndefinedKeyword", + "TSUnknownKeyword", + "TSVoidKeyword", + "TSThisType" + ].forEach(function(keywordType) { + def(keywordType).bases("TSType").build(); + }); + def("TSArrayType").bases("TSType").build("elementType").field("elementType", def("TSType")); + def("TSLiteralType").bases("TSType").build("literal").field("literal", or(def("NumericLiteral"), def("StringLiteral"), def("BooleanLiteral"), def("TemplateLiteral"), def("UnaryExpression"))); + [ + "TSUnionType", + "TSIntersectionType" + ].forEach(function(typeName) { + def(typeName).bases("TSType").build("types").field("types", [def("TSType")]); + }); + def("TSConditionalType").bases("TSType").build("checkType", "extendsType", "trueType", "falseType").field("checkType", def("TSType")).field("extendsType", def("TSType")).field("trueType", def("TSType")).field("falseType", def("TSType")); + def("TSInferType").bases("TSType").build("typeParameter").field("typeParameter", def("TSTypeParameter")); + def("TSParenthesizedType").bases("TSType").build("typeAnnotation").field("typeAnnotation", def("TSType")); + var ParametersType = [or(def("Identifier"), def("RestElement"), def("ArrayPattern"), def("ObjectPattern"))]; + [ + "TSFunctionType", + "TSConstructorType" + ].forEach(function(typeName) { + def(typeName).bases("TSType", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation").build("parameters").field("parameters", ParametersType); + }); + def("TSDeclareFunction").bases("Declaration", "TSHasOptionalTypeParameters").build("id", "params", "returnType").field("declare", Boolean, defaults["false"]).field("async", Boolean, defaults["false"]).field("generator", Boolean, defaults["false"]).field("id", or(def("Identifier"), null), defaults["null"]).field("params", [def("Pattern")]).field("returnType", or( + def("TSTypeAnnotation"), + def("Noop"), + // Still used? + null + ), defaults["null"]); + def("TSDeclareMethod").bases("Declaration", "TSHasOptionalTypeParameters").build("key", "params", "returnType").field("async", Boolean, defaults["false"]).field("generator", Boolean, defaults["false"]).field("params", [def("Pattern")]).field("abstract", Boolean, defaults["false"]).field("accessibility", or("public", "private", "protected", void 0), defaults["undefined"]).field("static", Boolean, defaults["false"]).field("computed", Boolean, defaults["false"]).field("optional", Boolean, defaults["false"]).field("key", or( + def("Identifier"), + def("StringLiteral"), + def("NumericLiteral"), + // Only allowed if .computed is true. + def("Expression") + )).field("kind", or("get", "set", "method", "constructor"), function getDefault() { + return "method"; + }).field( + "access", + // Not "accessibility"? + or("public", "private", "protected", void 0), + defaults["undefined"] + ).field("decorators", or([def("Decorator")], null), defaults["null"]).field("returnType", or( + def("TSTypeAnnotation"), + def("Noop"), + // Still used? + null + ), defaults["null"]); + def("TSMappedType").bases("TSType").build("typeParameter", "typeAnnotation").field("readonly", or(Boolean, "+", "-"), defaults["false"]).field("typeParameter", def("TSTypeParameter")).field("optional", or(Boolean, "+", "-"), defaults["false"]).field("typeAnnotation", or(def("TSType"), null), defaults["null"]); + def("TSTupleType").bases("TSType").build("elementTypes").field("elementTypes", [or(def("TSType"), def("TSNamedTupleMember"))]); + def("TSNamedTupleMember").bases("TSType").build("label", "elementType", "optional").field("label", def("Identifier")).field("optional", Boolean, defaults["false"]).field("elementType", def("TSType")); + def("TSRestType").bases("TSType").build("typeAnnotation").field("typeAnnotation", def("TSType")); + def("TSOptionalType").bases("TSType").build("typeAnnotation").field("typeAnnotation", def("TSType")); + def("TSIndexedAccessType").bases("TSType").build("objectType", "indexType").field("objectType", def("TSType")).field("indexType", def("TSType")); + def("TSTypeOperator").bases("TSType").build("operator").field("operator", String).field("typeAnnotation", def("TSType")); + def("TSTypeAnnotation").bases("Node").build("typeAnnotation").field("typeAnnotation", or(def("TSType"), def("TSTypeAnnotation"))); + def("TSIndexSignature").bases("Declaration", "TSHasOptionalTypeAnnotation").build("parameters", "typeAnnotation").field("parameters", [def("Identifier")]).field("readonly", Boolean, defaults["false"]); + def("TSPropertySignature").bases("Declaration", "TSHasOptionalTypeAnnotation").build("key", "typeAnnotation", "optional").field("key", def("Expression")).field("computed", Boolean, defaults["false"]).field("readonly", Boolean, defaults["false"]).field("optional", Boolean, defaults["false"]).field("initializer", or(def("Expression"), null), defaults["null"]); + def("TSMethodSignature").bases("Declaration", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation").build("key", "parameters", "typeAnnotation").field("key", def("Expression")).field("computed", Boolean, defaults["false"]).field("optional", Boolean, defaults["false"]).field("parameters", ParametersType); + def("TSTypePredicate").bases("TSTypeAnnotation", "TSType").build("parameterName", "typeAnnotation", "asserts").field("parameterName", or(def("Identifier"), def("TSThisType"))).field("typeAnnotation", or(def("TSTypeAnnotation"), null), defaults["null"]).field("asserts", Boolean, defaults["false"]); + [ + "TSCallSignatureDeclaration", + "TSConstructSignatureDeclaration" + ].forEach(function(typeName) { + def(typeName).bases("Declaration", "TSHasOptionalTypeParameters", "TSHasOptionalTypeAnnotation").build("parameters", "typeAnnotation").field("parameters", ParametersType); + }); + def("TSEnumMember").bases("Node").build("id", "initializer").field("id", or(def("Identifier"), StringLiteral)).field("initializer", or(def("Expression"), null), defaults["null"]); + def("TSTypeQuery").bases("TSType").build("exprName").field("exprName", or(TSEntityName, def("TSImportType"))); + var TSTypeMember = or(def("TSCallSignatureDeclaration"), def("TSConstructSignatureDeclaration"), def("TSIndexSignature"), def("TSMethodSignature"), def("TSPropertySignature")); + def("TSTypeLiteral").bases("TSType").build("members").field("members", [TSTypeMember]); + def("TSTypeParameter").bases("Identifier").build("name", "constraint", "default").field("name", String).field("constraint", or(def("TSType"), void 0), defaults["undefined"]).field("default", or(def("TSType"), void 0), defaults["undefined"]); + def("TSTypeAssertion").bases("Expression", "Pattern").build("typeAnnotation", "expression").field("typeAnnotation", def("TSType")).field("expression", def("Expression")).field("extra", or({ parenthesized: Boolean }, null), defaults["null"]); + def("TSTypeParameterDeclaration").bases("Declaration").build("params").field("params", [def("TSTypeParameter")]); + def("TSTypeParameterInstantiation").bases("Node").build("params").field("params", [def("TSType")]); + def("TSEnumDeclaration").bases("Declaration").build("id", "members").field("id", def("Identifier")).field("const", Boolean, defaults["false"]).field("declare", Boolean, defaults["false"]).field("members", [def("TSEnumMember")]).field("initializer", or(def("Expression"), null), defaults["null"]); + def("TSTypeAliasDeclaration").bases("Declaration", "TSHasOptionalTypeParameters").build("id", "typeAnnotation").field("id", def("Identifier")).field("declare", Boolean, defaults["false"]).field("typeAnnotation", def("TSType")); + def("TSModuleBlock").bases("Node").build("body").field("body", [def("Statement")]); + def("TSModuleDeclaration").bases("Declaration").build("id", "body").field("id", or(StringLiteral, TSEntityName)).field("declare", Boolean, defaults["false"]).field("global", Boolean, defaults["false"]).field("body", or(def("TSModuleBlock"), def("TSModuleDeclaration"), null), defaults["null"]); + def("TSImportType").bases("TSType", "TSHasOptionalTypeParameterInstantiation").build("argument", "qualifier", "typeParameters").field("argument", StringLiteral).field("qualifier", or(TSEntityName, void 0), defaults["undefined"]); + def("TSImportEqualsDeclaration").bases("Declaration").build("id", "moduleReference").field("id", def("Identifier")).field("isExport", Boolean, defaults["false"]).field("moduleReference", or(TSEntityName, def("TSExternalModuleReference"))); + def("TSExternalModuleReference").bases("Declaration").build("expression").field("expression", StringLiteral); + def("TSExportAssignment").bases("Statement").build("expression").field("expression", def("Expression")); + def("TSNamespaceExportDeclaration").bases("Declaration").build("id").field("id", def("Identifier")); + def("TSInterfaceBody").bases("Node").build("body").field("body", [TSTypeMember]); + def("TSExpressionWithTypeArguments").bases("TSType", "TSHasOptionalTypeParameterInstantiation").build("expression", "typeParameters").field("expression", TSEntityName); + def("TSInterfaceDeclaration").bases("Declaration", "TSHasOptionalTypeParameters").build("id", "body").field("id", TSEntityName).field("declare", Boolean, defaults["false"]).field("extends", or([def("TSExpressionWithTypeArguments")], null), defaults["null"]).field("body", def("TSInterfaceBody")); + def("TSParameterProperty").bases("Pattern").build("parameter").field("accessibility", or("public", "private", "protected", void 0), defaults["undefined"]).field("readonly", Boolean, defaults["false"]).field("parameter", or(def("Identifier"), def("AssignmentPattern"))); + def("ClassProperty").field( + "access", + // Not "accessibility"? + or("public", "private", "protected", void 0), + defaults["undefined"] + ); + def("ClassBody").field("body", [or( + def("MethodDefinition"), + def("VariableDeclarator"), + def("ClassPropertyDefinition"), + def("ClassProperty"), + def("ClassPrivateProperty"), + def("ClassMethod"), + def("ClassPrivateMethod"), + // Just need to add these types: + def("TSDeclareMethod"), + TSTypeMember + )]); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/def/es-proposals.js +var require_es_proposals = __commonJS({ + "../testeranto/node_modules/ast-types/def/es-proposals.js"(exports, module) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var types_1 = tslib_1.__importDefault(require_types()); + var shared_1 = tslib_1.__importDefault(require_shared()); + var core_1 = tslib_1.__importDefault(require_core()); + function default_1(fork) { + fork.use(core_1.default); + var types = fork.use(types_1.default); + var Type = types.Type; + var def = types.Type.def; + var or = Type.or; + var shared = fork.use(shared_1.default); + var defaults = shared.defaults; + def("OptionalMemberExpression").bases("MemberExpression").build("object", "property", "computed", "optional").field("optional", Boolean, defaults["true"]); + def("OptionalCallExpression").bases("CallExpression").build("callee", "arguments", "optional").field("optional", Boolean, defaults["true"]); + var LogicalOperator = or("||", "&&", "??"); + def("LogicalExpression").field("operator", LogicalOperator); + } + exports.default = default_1; + module.exports = exports["default"]; + } +}); + +// ../testeranto/node_modules/ast-types/gen/namedTypes.js +var require_namedTypes = __commonJS({ + "../testeranto/node_modules/ast-types/gen/namedTypes.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.namedTypes = void 0; + var namedTypes; + (function(namedTypes2) { + })(namedTypes = exports.namedTypes || (exports.namedTypes = {})); + } +}); + +// ../testeranto/node_modules/ast-types/main.js +var require_main = __commonJS({ + "../testeranto/node_modules/ast-types/main.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.visit = exports.use = exports.Type = exports.someField = exports.PathVisitor = exports.Path = exports.NodePath = exports.namedTypes = exports.getSupertypeNames = exports.getFieldValue = exports.getFieldNames = exports.getBuilderName = exports.finalize = exports.eachField = exports.defineMethod = exports.builtInTypes = exports.builders = exports.astNodesAreEquivalent = void 0; + var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); + var fork_1 = tslib_1.__importDefault(require_fork()); + var core_1 = tslib_1.__importDefault(require_core()); + var es6_1 = tslib_1.__importDefault(require_es6()); + var es7_1 = tslib_1.__importDefault(require_es7()); + var es2020_1 = tslib_1.__importDefault(require_es2020()); + var jsx_1 = tslib_1.__importDefault(require_jsx()); + var flow_1 = tslib_1.__importDefault(require_flow()); + var esprima_1 = tslib_1.__importDefault(require_esprima2()); + var babel_1 = tslib_1.__importDefault(require_babel()); + var typescript_1 = tslib_1.__importDefault(require_typescript()); + var es_proposals_1 = tslib_1.__importDefault(require_es_proposals()); + var namedTypes_1 = require_namedTypes(); + Object.defineProperty(exports, "namedTypes", { enumerable: true, get: function() { + return namedTypes_1.namedTypes; + } }); + var _a2 = fork_1.default([ + // This core module of AST types captures ES5 as it is parsed today by + // git://github.com/ariya/esprima.git#master. + core_1.default, + // Feel free to add to or remove from this list of extension modules to + // configure the precise type hierarchy that you need. + es6_1.default, + es7_1.default, + es2020_1.default, + jsx_1.default, + flow_1.default, + esprima_1.default, + babel_1.default, + typescript_1.default, + es_proposals_1.default + ]); + var astNodesAreEquivalent = _a2.astNodesAreEquivalent; + var builders = _a2.builders; + var builtInTypes = _a2.builtInTypes; + var defineMethod = _a2.defineMethod; + var eachField = _a2.eachField; + var finalize = _a2.finalize; + var getBuilderName = _a2.getBuilderName; + var getFieldNames = _a2.getFieldNames; + var getFieldValue = _a2.getFieldValue; + var getSupertypeNames = _a2.getSupertypeNames; + var n = _a2.namedTypes; + var NodePath = _a2.NodePath; + var Path = _a2.Path; + var PathVisitor = _a2.PathVisitor; + var someField = _a2.someField; + var Type = _a2.Type; + var use2 = _a2.use; + var visit = _a2.visit; + exports.astNodesAreEquivalent = astNodesAreEquivalent; + exports.builders = builders; + exports.builtInTypes = builtInTypes; + exports.defineMethod = defineMethod; + exports.eachField = eachField; + exports.finalize = finalize; + exports.getBuilderName = getBuilderName; + exports.getFieldNames = getFieldNames; + exports.getFieldValue = getFieldValue; + exports.getSupertypeNames = getSupertypeNames; + exports.NodePath = NodePath; + exports.Path = Path; + exports.PathVisitor = PathVisitor; + exports.someField = someField; + exports.Type = Type; + exports.use = use2; + exports.visit = visit; + Object.assign(namedTypes_1.namedTypes, n); + } +}); + +// ../testeranto/node_modules/degenerator/dist/degenerator.js +var require_degenerator = __commonJS({ + "../testeranto/node_modules/degenerator/dist/degenerator.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.degenerator = void 0; + var util_1 = __require("util"); + var escodegen_1 = require_escodegen(); + var esprima_1 = require_esprima(); + var ast_types_1 = require_main(); + function degenerator(code, _names) { + if (!Array.isArray(_names)) { + throw new TypeError('an array of async function "names" is required'); + } + const names = _names.slice(0); + const ast = (0, esprima_1.parseScript)(code); + let lastNamesLength = 0; + do { + lastNamesLength = names.length; + (0, ast_types_1.visit)(ast, { + visitVariableDeclaration(path10) { + if (path10.node.declarations) { + for (let i = 0; i < path10.node.declarations.length; i++) { + const declaration = path10.node.declarations[i]; + if (ast_types_1.namedTypes.VariableDeclarator.check(declaration) && ast_types_1.namedTypes.Identifier.check(declaration.init) && ast_types_1.namedTypes.Identifier.check(declaration.id) && checkName(declaration.init.name, names) && !checkName(declaration.id.name, names)) { + names.push(declaration.id.name); + } + } + } + return false; + }, + visitAssignmentExpression(path10) { + if (ast_types_1.namedTypes.Identifier.check(path10.node.left) && ast_types_1.namedTypes.Identifier.check(path10.node.right) && checkName(path10.node.right.name, names) && !checkName(path10.node.left.name, names)) { + names.push(path10.node.left.name); + } + return false; + }, + visitFunction(path10) { + if (path10.node.id) { + let shouldDegenerate = false; + (0, ast_types_1.visit)(path10.node, { + visitCallExpression(path11) { + if (checkNames(path11.node, names)) { + shouldDegenerate = true; + } + return false; + } + }); + if (!shouldDegenerate) { + return false; + } + path10.node.async = true; + if (!checkName(path10.node.id.name, names)) { + names.push(path10.node.id.name); + } + } + this.traverse(path10); + } + }); + } while (lastNamesLength !== names.length); + (0, ast_types_1.visit)(ast, { + visitCallExpression(path10) { + if (checkNames(path10.node, names)) { + const delegate = false; + const { name, parent: { node: pNode } } = path10; + const expr = ast_types_1.builders.awaitExpression(path10.node, delegate); + if (ast_types_1.namedTypes.CallExpression.check(pNode)) { + pNode.arguments[name] = expr; + } else { + pNode[name] = expr; + } + } + this.traverse(path10); + } + }); + return (0, escodegen_1.generate)(ast); + } + exports.degenerator = degenerator; + function checkNames({ callee }, names) { + let name; + if (ast_types_1.namedTypes.Identifier.check(callee)) { + name = callee.name; + } else if (ast_types_1.namedTypes.MemberExpression.check(callee)) { + if (ast_types_1.namedTypes.Identifier.check(callee.object) && ast_types_1.namedTypes.Identifier.check(callee.property)) { + name = `${callee.object.name}.${callee.property.name}`; + } else { + return false; + } + } else if (ast_types_1.namedTypes.FunctionExpression.check(callee)) { + if (callee.id) { + name = callee.id.name; + } else { + return false; + } + } else { + throw new Error(`Don't know how to get name for: ${callee.type}`); + } + return checkName(name, names); + } + function checkName(name, names) { + for (let i = 0; i < names.length; i++) { + const n = names[i]; + if (util_1.types.isRegExp(n)) { + if (n.test(name)) { + return true; + } + } else if (name === n) { + return true; + } + } + return false; + } + } +}); + +// ../testeranto/node_modules/degenerator/dist/compile.js +var require_compile = __commonJS({ + "../testeranto/node_modules/degenerator/dist/compile.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.compile = void 0; + var util_1 = __require("util"); + var degenerator_1 = require_degenerator(); + function compile(qjs, code, returnName, options = {}) { + const compiled = (0, degenerator_1.degenerator)(code, options.names ?? []); + const vm = qjs.newContext(); + if (options.sandbox) { + for (const [name, value] of Object.entries(options.sandbox)) { + if (typeof value !== "function") { + throw new Error(`Expected a "function" for sandbox property \`${name}\`, but got "${typeof value}"`); + } + const fnHandle = vm.newFunction(name, (...args) => { + const result = value(...args.map((arg) => quickJSHandleToHost(vm, arg))); + vm.runtime.executePendingJobs(); + return hostToQuickJSHandle(vm, result); + }); + fnHandle.consume((handle) => vm.setProp(vm.global, name, handle)); + } + } + const fnResult = vm.evalCode(`${compiled};${returnName}`, options.filename); + const fn = vm.unwrapResult(fnResult); + const t = vm.typeof(fn); + if (t !== "function") { + throw new Error(`Expected a "function" named \`${returnName}\` to be defined, but got "${t}"`); + } + const r = async function(...args) { + let promiseHandle; + let resolvedHandle; + try { + const result = vm.callFunction(fn, vm.undefined, ...args.map((arg) => hostToQuickJSHandle(vm, arg))); + promiseHandle = vm.unwrapResult(result); + const resolvedResultP = vm.resolvePromise(promiseHandle); + vm.runtime.executePendingJobs(); + const resolvedResult = await resolvedResultP; + resolvedHandle = vm.unwrapResult(resolvedResult); + return quickJSHandleToHost(vm, resolvedHandle); + } catch (err) { + if (err && typeof err === "object" && "cause" in err && err.cause) { + if (typeof err.cause === "object" && "stack" in err.cause && "name" in err.cause && "message" in err.cause && typeof err.cause.stack === "string" && typeof err.cause.name === "string" && typeof err.cause.message === "string") { + err.cause.stack = `${err.cause.name}: ${err.cause.message} +${err.cause.stack}`; + } + throw err.cause; + } + throw err; + } finally { + promiseHandle?.dispose(); + resolvedHandle?.dispose(); + } + }; + Object.defineProperty(r, "toString", { + value: () => compiled, + enumerable: false + }); + return r; + } + exports.compile = compile; + function quickJSHandleToHost(vm, val) { + return vm.dump(val); + } + function hostToQuickJSHandle(vm, val) { + if (typeof val === "undefined") { + return vm.undefined; + } else if (val === null) { + return vm.null; + } else if (typeof val === "string") { + return vm.newString(val); + } else if (typeof val === "number") { + return vm.newNumber(val); + } else if (typeof val === "bigint") { + return vm.newBigInt(val); + } else if (typeof val === "boolean") { + return val ? vm.true : vm.false; + } else if (util_1.types.isPromise(val)) { + const promise = vm.newPromise(); + promise.settled.then(vm.runtime.executePendingJobs); + val.then((r) => { + promise.resolve(hostToQuickJSHandle(vm, r)); + }, (err) => { + promise.reject(hostToQuickJSHandle(vm, err)); + }); + return promise.handle; + } else if (util_1.types.isNativeError(val)) { + return vm.newError(val); + } + throw new Error(`Unsupported value: ${val}`); + } + } +}); + +// ../testeranto/node_modules/degenerator/dist/index.js +var require_dist7 = __commonJS({ + "../testeranto/node_modules/degenerator/dist/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __exportStar2 = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) + __createBinding2(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + __exportStar2(require_degenerator(), exports); + __exportStar2(require_compile(), exports); + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/dateRange.js +var require_dateRange = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/dateRange.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + function dateRange() { + return false; + } + exports.default = dateRange; + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/dnsDomainIs.js +var require_dnsDomainIs = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/dnsDomainIs.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + function dnsDomainIs(host, domain) { + host = String(host); + domain = String(domain); + return host.substr(domain.length * -1) === domain; + } + exports.default = dnsDomainIs; + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/dnsDomainLevels.js +var require_dnsDomainLevels = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/dnsDomainLevels.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + function dnsDomainLevels(host) { + const match = String(host).match(/\./g); + let levels = 0; + if (match) { + levels = match.length; + } + return levels; + } + exports.default = dnsDomainLevels; + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/util.js +var require_util3 = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/util.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isGMT = exports.dnsLookup = void 0; + var dns_1 = __require("dns"); + function dnsLookup(host, opts) { + return new Promise((resolve5, reject) => { + (0, dns_1.lookup)(host, opts, (err, res) => { + if (err) { + reject(err); + } else { + resolve5(res); + } + }); + }); + } + exports.dnsLookup = dnsLookup; + function isGMT(v) { + return v === "GMT"; + } + exports.isGMT = isGMT; + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/dnsResolve.js +var require_dnsResolve = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/dnsResolve.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var util_1 = require_util3(); + async function dnsResolve(host) { + const family = 4; + try { + const r = await (0, util_1.dnsLookup)(host, { family }); + if (typeof r === "string") { + return r; + } + } catch (err) { + } + return null; + } + exports.default = dnsResolve; + } +}); + +// ../testeranto/node_modules/netmask/lib/netmask.js +var require_netmask = __commonJS({ + "../testeranto/node_modules/netmask/lib/netmask.js"(exports) { + init_cjs_shim(); + (function() { + var Netmask, atob2, chr, chr0, chrA, chra, ip2long, long2ip; + long2ip = function(long) { + var a, b, c, d; + a = (long & 255 << 24) >>> 24; + b = (long & 255 << 16) >>> 16; + c = (long & 255 << 8) >>> 8; + d = long & 255; + return [a, b, c, d].join("."); + }; + ip2long = function(ip) { + var b, c, i, j, n, ref; + b = []; + for (i = j = 0; j <= 3; i = ++j) { + if (ip.length === 0) { + break; + } + if (i > 0) { + if (ip[0] !== ".") { + throw new Error("Invalid IP"); + } + ip = ip.substring(1); + } + ref = atob2(ip), n = ref[0], c = ref[1]; + ip = ip.substring(c); + b.push(n); + } + if (ip.length !== 0) { + throw new Error("Invalid IP"); + } + switch (b.length) { + case 1: + if (b[0] > 4294967295) { + throw new Error("Invalid IP"); + } + return b[0] >>> 0; + case 2: + if (b[0] > 255 || b[1] > 16777215) { + throw new Error("Invalid IP"); + } + return (b[0] << 24 | b[1]) >>> 0; + case 3: + if (b[0] > 255 || b[1] > 255 || b[2] > 65535) { + throw new Error("Invalid IP"); + } + return (b[0] << 24 | b[1] << 16 | b[2]) >>> 0; + case 4: + if (b[0] > 255 || b[1] > 255 || b[2] > 255 || b[3] > 255) { + throw new Error("Invalid IP"); + } + return (b[0] << 24 | b[1] << 16 | b[2] << 8 | b[3]) >>> 0; + default: + throw new Error("Invalid IP"); + } + }; + chr = function(b) { + return b.charCodeAt(0); + }; + chr0 = chr("0"); + chra = chr("a"); + chrA = chr("A"); + atob2 = function(s) { + var base, dmax, i, n, start; + n = 0; + base = 10; + dmax = "9"; + i = 0; + if (s.length > 1 && s[i] === "0") { + if (s[i + 1] === "x" || s[i + 1] === "X") { + i += 2; + base = 16; + } else if ("0" <= s[i + 1] && s[i + 1] <= "9") { + i++; + base = 8; + dmax = "7"; + } + } + start = i; + while (i < s.length) { + if ("0" <= s[i] && s[i] <= dmax) { + n = n * base + (chr(s[i]) - chr0) >>> 0; + } else if (base === 16) { + if ("a" <= s[i] && s[i] <= "f") { + n = n * base + (10 + chr(s[i]) - chra) >>> 0; + } else if ("A" <= s[i] && s[i] <= "F") { + n = n * base + (10 + chr(s[i]) - chrA) >>> 0; + } else { + break; + } + } else { + break; + } + if (n > 4294967295) { + throw new Error("too large"); + } + i++; + } + if (i === start) { + throw new Error("empty octet"); + } + return [n, i]; + }; + Netmask = function() { + function Netmask2(net, mask) { + var error, i, j, ref; + if (typeof net !== "string") { + throw new Error("Missing `net' parameter"); + } + if (!mask) { + ref = net.split("/", 2), net = ref[0], mask = ref[1]; + } + if (!mask) { + mask = 32; + } + if (typeof mask === "string" && mask.indexOf(".") > -1) { + try { + this.maskLong = ip2long(mask); + } catch (error1) { + error = error1; + throw new Error("Invalid mask: " + mask); + } + for (i = j = 32; j >= 0; i = --j) { + if (this.maskLong === 4294967295 << 32 - i >>> 0) { + this.bitmask = i; + break; + } + } + } else if (mask || mask === 0) { + this.bitmask = parseInt(mask, 10); + this.maskLong = 0; + if (this.bitmask > 0) { + this.maskLong = 4294967295 << 32 - this.bitmask >>> 0; + } + } else { + throw new Error("Invalid mask: empty"); + } + try { + this.netLong = (ip2long(net) & this.maskLong) >>> 0; + } catch (error1) { + error = error1; + throw new Error("Invalid net address: " + net); + } + if (!(this.bitmask <= 32)) { + throw new Error("Invalid mask for ip4: " + mask); + } + this.size = Math.pow(2, 32 - this.bitmask); + this.base = long2ip(this.netLong); + this.mask = long2ip(this.maskLong); + this.hostmask = long2ip(~this.maskLong); + this.first = this.bitmask <= 30 ? long2ip(this.netLong + 1) : this.base; + this.last = this.bitmask <= 30 ? long2ip(this.netLong + this.size - 2) : long2ip(this.netLong + this.size - 1); + this.broadcast = this.bitmask <= 30 ? long2ip(this.netLong + this.size - 1) : void 0; + } + Netmask2.prototype.contains = function(ip) { + if (typeof ip === "string" && (ip.indexOf("/") > 0 || ip.split(".").length !== 4)) { + ip = new Netmask2(ip); + } + if (ip instanceof Netmask2) { + return this.contains(ip.base) && this.contains(ip.broadcast || ip.last); + } else { + return (ip2long(ip) & this.maskLong) >>> 0 === (this.netLong & this.maskLong) >>> 0; + } + }; + Netmask2.prototype.next = function(count) { + if (count == null) { + count = 1; + } + return new Netmask2(long2ip(this.netLong + this.size * count), this.mask); + }; + Netmask2.prototype.forEach = function(fn) { + var index, lastLong, long; + long = ip2long(this.first); + lastLong = ip2long(this.last); + index = 0; + while (long <= lastLong) { + fn(long2ip(long), long, index); + index++; + long++; + } + }; + Netmask2.prototype.toString = function() { + return this.base + "/" + this.bitmask; + }; + return Netmask2; + }(); + exports.ip2long = ip2long; + exports.long2ip = long2ip; + exports.Netmask = Netmask; + }).call(exports); + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/isInNet.js +var require_isInNet = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/isInNet.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var netmask_1 = require_netmask(); + var util_1 = require_util3(); + async function isInNet(host, pattern, mask) { + const family = 4; + try { + const ip = await (0, util_1.dnsLookup)(host, { family }); + if (typeof ip === "string") { + const netmask = new netmask_1.Netmask(pattern, mask); + return netmask.contains(ip); + } + } catch (err) { + } + return false; + } + exports.default = isInNet; + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/isPlainHostName.js +var require_isPlainHostName = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/isPlainHostName.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + function isPlainHostName(host) { + return !/\./.test(host); + } + exports.default = isPlainHostName; + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/isResolvable.js +var require_isResolvable = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/isResolvable.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var util_1 = require_util3(); + async function isResolvable(host) { + const family = 4; + try { + if (await (0, util_1.dnsLookup)(host, { family })) { + return true; + } + } catch (err) { + } + return false; + } + exports.default = isResolvable; + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/localHostOrDomainIs.js +var require_localHostOrDomainIs = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/localHostOrDomainIs.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + function localHostOrDomainIs(host, hostdom) { + const parts = host.split("."); + const domparts = hostdom.split("."); + let matches = true; + for (let i = 0; i < parts.length; i++) { + if (parts[i] !== domparts[i]) { + matches = false; + break; + } + } + return matches; + } + exports.default = localHostOrDomainIs; + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/ip.js +var require_ip = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/ip.js"(exports) { + "use strict"; + init_cjs_shim(); + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ip = void 0; + var os_1 = __importDefault2(__require("os")); + exports.ip = { + address() { + const interfaces = os_1.default.networkInterfaces(); + const family = normalizeFamily(); + const all = Object.values(interfaces).map((addrs = []) => { + const addresses = addrs.filter((details) => { + const detailsFamily = normalizeFamily(details.family); + if (detailsFamily !== family || exports.ip.isLoopback(details.address)) { + return false; + } + return true; + }); + return addresses.length ? addresses[0].address : void 0; + }).filter(Boolean); + return !all.length ? exports.ip.loopback(family) : all[0]; + }, + isLoopback(addr) { + return /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})/.test(addr) || /^fe80::1$/.test(addr) || /^::1$/.test(addr) || /^::$/.test(addr); + }, + loopback(family) { + family = normalizeFamily(family); + if (family !== "ipv4" && family !== "ipv6") { + throw new Error("family must be ipv4 or ipv6"); + } + return family === "ipv4" ? "127.0.0.1" : "fe80::1"; + } + }; + function normalizeFamily(family) { + if (family === 4) { + return "ipv4"; + } + if (family === 6) { + return "ipv6"; + } + return family ? family.toLowerCase() : "ipv4"; + } + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/myIpAddress.js +var require_myIpAddress = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/myIpAddress.js"(exports) { + "use strict"; + init_cjs_shim(); + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + var ip_1 = require_ip(); + var net_1 = __importDefault2(__require("net")); + async function myIpAddress() { + return new Promise((resolve5, reject) => { + const socket = net_1.default.connect({ host: "8.8.8.8", port: 53 }); + const onError = () => { + resolve5(ip_1.ip.address()); + }; + socket.once("error", onError); + socket.once("connect", () => { + socket.removeListener("error", onError); + const addr = socket.address(); + socket.destroy(); + if (typeof addr === "string") { + resolve5(addr); + } else if (addr.address) { + resolve5(addr.address); + } else { + reject(new Error("Expected a `string`")); + } + }); + }); + } + exports.default = myIpAddress; + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/shExpMatch.js +var require_shExpMatch = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/shExpMatch.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + function shExpMatch(str, shexp) { + const re = toRegExp(shexp); + return re.test(str); + } + exports.default = shExpMatch; + function toRegExp(str) { + str = String(str).replace(/\./g, "\\.").replace(/\?/g, ".").replace(/\*/g, ".*"); + return new RegExp(`^${str}$`); + } + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/timeRange.js +var require_timeRange = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/timeRange.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + function timeRange() { + const args = Array.prototype.slice.call(arguments); + const lastArg = args.pop(); + const useGMTzone = lastArg === "GMT"; + const currentDate = /* @__PURE__ */ new Date(); + if (!useGMTzone) { + args.push(lastArg); + } + let result = false; + const noOfArgs = args.length; + const numericArgs = args.map((n) => parseInt(n, 10)); + if (noOfArgs === 1) { + result = getCurrentHour(useGMTzone, currentDate) === numericArgs[0]; + } else if (noOfArgs === 2) { + const currentHour = getCurrentHour(useGMTzone, currentDate); + result = numericArgs[0] <= currentHour && currentHour < numericArgs[1]; + } else if (noOfArgs === 4) { + result = valueInRange(secondsElapsedToday(numericArgs[0], numericArgs[1], 0), secondsElapsedToday(getCurrentHour(useGMTzone, currentDate), getCurrentMinute(useGMTzone, currentDate), 0), secondsElapsedToday(numericArgs[2], numericArgs[3], 59)); + } else if (noOfArgs === 6) { + result = valueInRange(secondsElapsedToday(numericArgs[0], numericArgs[1], numericArgs[2]), secondsElapsedToday(getCurrentHour(useGMTzone, currentDate), getCurrentMinute(useGMTzone, currentDate), getCurrentSecond(useGMTzone, currentDate)), secondsElapsedToday(numericArgs[3], numericArgs[4], numericArgs[5])); + } + return result; + } + exports.default = timeRange; + function secondsElapsedToday(hh, mm, ss) { + return hh * 3600 + mm * 60 + ss; + } + function getCurrentHour(gmt, currentDate) { + return gmt ? currentDate.getUTCHours() : currentDate.getHours(); + } + function getCurrentMinute(gmt, currentDate) { + return gmt ? currentDate.getUTCMinutes() : currentDate.getMinutes(); + } + function getCurrentSecond(gmt, currentDate) { + return gmt ? currentDate.getUTCSeconds() : currentDate.getSeconds(); + } + function valueInRange(start, value, finish) { + return start <= value && value <= finish; + } + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/weekdayRange.js +var require_weekdayRange = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/weekdayRange.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + var util_1 = require_util3(); + var weekdays = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]; + function weekdayRange(wd1, wd2, gmt) { + let useGMTzone = false; + let wd1Index = -1; + let wd2Index = -1; + let wd2IsGmt = false; + if ((0, util_1.isGMT)(gmt)) { + useGMTzone = true; + } else if ((0, util_1.isGMT)(wd2)) { + useGMTzone = true; + wd2IsGmt = true; + } + wd1Index = weekdays.indexOf(wd1); + if (!wd2IsGmt && isWeekday(wd2)) { + wd2Index = weekdays.indexOf(wd2); + } + const todaysDay = getTodaysDay(useGMTzone); + let result; + if (wd2Index < 0) { + result = todaysDay === wd1Index; + } else if (wd1Index <= wd2Index) { + result = valueInRange(wd1Index, todaysDay, wd2Index); + } else { + result = valueInRange(wd1Index, todaysDay, 6) || valueInRange(0, todaysDay, wd2Index); + } + return result; + } + exports.default = weekdayRange; + function getTodaysDay(gmt) { + return gmt ? (/* @__PURE__ */ new Date()).getUTCDay() : (/* @__PURE__ */ new Date()).getDay(); + } + function valueInRange(start, value, finish) { + return start <= value && value <= finish; + } + function isWeekday(v) { + if (!v) + return false; + return weekdays.includes(v); + } + } +}); + +// ../testeranto/node_modules/pac-resolver/dist/index.js +var require_dist8 = __commonJS({ + "../testeranto/node_modules/pac-resolver/dist/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.sandbox = exports.createPacResolver = void 0; + var degenerator_1 = require_dist7(); + var dateRange_1 = __importDefault2(require_dateRange()); + var dnsDomainIs_1 = __importDefault2(require_dnsDomainIs()); + var dnsDomainLevels_1 = __importDefault2(require_dnsDomainLevels()); + var dnsResolve_1 = __importDefault2(require_dnsResolve()); + var isInNet_1 = __importDefault2(require_isInNet()); + var isPlainHostName_1 = __importDefault2(require_isPlainHostName()); + var isResolvable_1 = __importDefault2(require_isResolvable()); + var localHostOrDomainIs_1 = __importDefault2(require_localHostOrDomainIs()); + var myIpAddress_1 = __importDefault2(require_myIpAddress()); + var shExpMatch_1 = __importDefault2(require_shExpMatch()); + var timeRange_1 = __importDefault2(require_timeRange()); + var weekdayRange_1 = __importDefault2(require_weekdayRange()); + function createPacResolver(qjs, _str, _opts = {}) { + const str = Buffer.isBuffer(_str) ? _str.toString("utf8") : _str; + const context = { + ...exports.sandbox, + ..._opts.sandbox + }; + const names = Object.keys(context).filter((k) => isAsyncFunction(context[k])); + const opts = { + filename: "proxy.pac", + names, + ..._opts, + sandbox: context + }; + const resolver = (0, degenerator_1.compile)(qjs, str, "FindProxyForURL", opts); + function FindProxyForURL(url, _host) { + const urlObj = typeof url === "string" ? new URL(url) : url; + const host = _host || urlObj.hostname; + if (!host) { + throw new TypeError("Could not determine `host`"); + } + return resolver(urlObj.href, host); + } + Object.defineProperty(FindProxyForURL, "toString", { + value: () => resolver.toString(), + enumerable: false + }); + return FindProxyForURL; + } + exports.createPacResolver = createPacResolver; + exports.sandbox = Object.freeze({ + alert: (message = "") => console.log("%s", message), + dateRange: dateRange_1.default, + dnsDomainIs: dnsDomainIs_1.default, + dnsDomainLevels: dnsDomainLevels_1.default, + dnsResolve: dnsResolve_1.default, + isInNet: isInNet_1.default, + isPlainHostName: isPlainHostName_1.default, + isResolvable: isResolvable_1.default, + localHostOrDomainIs: localHostOrDomainIs_1.default, + myIpAddress: myIpAddress_1.default, + shExpMatch: shExpMatch_1.default, + timeRange: timeRange_1.default, + weekdayRange: weekdayRange_1.default + }); + function isAsyncFunction(v) { + if (typeof v !== "function") + return false; + if (v.constructor.name === "AsyncFunction") + return true; + if (String(v).indexOf("__awaiter(") !== -1) + return true; + return Boolean(v.async); + } + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/esmHelpers.js +var require_esmHelpers = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/esmHelpers.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.unwrapJavascript = exports.unwrapTypescript = void 0; + function fakeUnwrapDefault(mod) { + return mod.default; + } + function actualUnwrapDefault(mod) { + const maybeUnwrap = mod.default; + return maybeUnwrap ?? mod; + } + exports.unwrapTypescript = actualUnwrapDefault; + exports.unwrapJavascript = fakeUnwrapDefault; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/debug.js +var require_debug2 = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/debug.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.debugLog = exports.QTS_DEBUG = void 0; + exports.QTS_DEBUG = Boolean(typeof process === "object" && process.env.QTS_DEBUG); + exports.debugLog = exports.QTS_DEBUG ? console.log.bind(console) : () => { + }; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/errors.js +var require_errors = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/errors.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.QuickJSMemoryLeakDetected = exports.QuickJSAsyncifySuspended = exports.QuickJSAsyncifyError = exports.QuickJSNotImplemented = exports.QuickJSUseAfterFree = exports.QuickJSWrongOwner = exports.QuickJSUnwrapError = void 0; + var QuickJSUnwrapError = class extends Error { + constructor(cause, context) { + super(String(cause)); + this.cause = cause; + this.context = context; + this.name = "QuickJSUnwrapError"; + } + }; + exports.QuickJSUnwrapError = QuickJSUnwrapError; + var QuickJSWrongOwner = class extends Error { + constructor() { + super(...arguments); + this.name = "QuickJSWrongOwner"; + } + }; + exports.QuickJSWrongOwner = QuickJSWrongOwner; + var QuickJSUseAfterFree = class extends Error { + constructor() { + super(...arguments); + this.name = "QuickJSUseAfterFree"; + } + }; + exports.QuickJSUseAfterFree = QuickJSUseAfterFree; + var QuickJSNotImplemented = class extends Error { + constructor() { + super(...arguments); + this.name = "QuickJSNotImplemented"; + } + }; + exports.QuickJSNotImplemented = QuickJSNotImplemented; + var QuickJSAsyncifyError = class extends Error { + constructor() { + super(...arguments); + this.name = "QuickJSAsyncifyError"; + } + }; + exports.QuickJSAsyncifyError = QuickJSAsyncifyError; + var QuickJSAsyncifySuspended = class extends Error { + constructor() { + super(...arguments); + this.name = "QuickJSAsyncifySuspended"; + } + }; + exports.QuickJSAsyncifySuspended = QuickJSAsyncifySuspended; + var QuickJSMemoryLeakDetected = class extends Error { + constructor() { + super(...arguments); + this.name = "QuickJSMemoryLeakDetected"; + } + }; + exports.QuickJSMemoryLeakDetected = QuickJSMemoryLeakDetected; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/asyncify-helpers.js +var require_asyncify_helpers = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/asyncify-helpers.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.awaitEachYieldedPromise = exports.maybeAsync = exports.maybeAsyncFn = void 0; + function* awaitYield(value) { + return yield value; + } + function awaitYieldOf(generator) { + return awaitYield(awaitEachYieldedPromise(generator)); + } + var AwaitYield = awaitYield; + AwaitYield.of = awaitYieldOf; + function maybeAsyncFn(that, fn) { + return (...args) => { + const generator = fn.call(that, AwaitYield, ...args); + return awaitEachYieldedPromise(generator); + }; + } + exports.maybeAsyncFn = maybeAsyncFn; + function maybeAsync(that, startGenerator) { + const generator = startGenerator.call(that, AwaitYield); + return awaitEachYieldedPromise(generator); + } + exports.maybeAsync = maybeAsync; + function awaitEachYieldedPromise(gen) { + function handleNextStep(step) { + if (step.done) { + return step.value; + } + if (step.value instanceof Promise) { + return step.value.then((value) => handleNextStep(gen.next(value)), (error) => handleNextStep(gen.throw(error))); + } + return handleNextStep(gen.next(step.value)); + } + return handleNextStep(gen.next()); + } + exports.awaitEachYieldedPromise = awaitEachYieldedPromise; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/lifetime.js +var require_lifetime = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/lifetime.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Scope = exports.WeakLifetime = exports.StaticLifetime = exports.Lifetime = void 0; + var asyncify_helpers_1 = require_asyncify_helpers(); + var debug_1 = require_debug2(); + var errors_1 = require_errors(); + var Lifetime = class { + /** + * When the Lifetime is disposed, it will call `disposer(_value)`. Use the + * disposer function to implement whatever cleanup needs to happen at the end + * of `value`'s lifetime. + * + * `_owner` is not used or controlled by the lifetime. It's just metadata for + * the creator. + */ + constructor(_value, copier, disposer, _owner) { + this._value = _value; + this.copier = copier; + this.disposer = disposer; + this._owner = _owner; + this._alive = true; + this._constructorStack = debug_1.QTS_DEBUG ? new Error("Lifetime constructed").stack : void 0; + } + get alive() { + return this._alive; + } + /** + * The value this Lifetime protects. You must never retain the value - it + * may become invalid, leading to memory errors. + * + * @throws If the lifetime has been [[dispose]]d already. + */ + get value() { + this.assertAlive(); + return this._value; + } + get owner() { + return this._owner; + } + get dupable() { + return !!this.copier; + } + /** + * Create a new handle pointing to the same [[value]]. + */ + dup() { + this.assertAlive(); + if (!this.copier) { + throw new Error("Non-dupable lifetime"); + } + return new Lifetime(this.copier(this._value), this.copier, this.disposer, this._owner); + } + consume(map2) { + this.assertAlive(); + const result = map2(this); + this.dispose(); + return result; + } + /** + * Dispose of [[value]] and perform cleanup. + */ + dispose() { + this.assertAlive(); + if (this.disposer) { + this.disposer(this._value); + } + this._alive = false; + } + assertAlive() { + if (!this.alive) { + if (this._constructorStack) { + throw new errors_1.QuickJSUseAfterFree(`Lifetime not alive +${this._constructorStack} +Lifetime used`); + } + throw new errors_1.QuickJSUseAfterFree("Lifetime not alive"); + } + } + }; + exports.Lifetime = Lifetime; + var StaticLifetime = class extends Lifetime { + constructor(value, owner) { + super(value, void 0, void 0, owner); + } + // Static lifetime doesn't need a copier to be copiable + get dupable() { + return true; + } + // Copy returns the same instance. + dup() { + return this; + } + // Dispose does nothing. + dispose() { + } + }; + exports.StaticLifetime = StaticLifetime; + var WeakLifetime = class extends Lifetime { + constructor(value, copier, disposer, owner) { + super(value, copier, disposer, owner); + } + dispose() { + this._alive = false; + } + }; + exports.WeakLifetime = WeakLifetime; + function scopeFinally(scope, blockError) { + let disposeError; + try { + scope.dispose(); + } catch (error) { + disposeError = error; + } + if (blockError && disposeError) { + Object.assign(blockError, { + message: `${blockError.message} + Then, failed to dispose scope: ${disposeError.message}`, + disposeError + }); + throw blockError; + } + if (blockError || disposeError) { + throw blockError || disposeError; + } + } + var Scope = class { + constructor() { + this._disposables = new Lifetime(/* @__PURE__ */ new Set()); + } + /** + * Run `block` with a new Scope instance that will be disposed after the block returns. + * Inside `block`, call `scope.manage` on each lifetime you create to have the lifetime + * automatically disposed after the block returns. + * + * @warning Do not use with async functions. Instead, use [[withScopeAsync]]. + */ + static withScope(block) { + const scope = new Scope(); + let blockError; + try { + return block(scope); + } catch (error) { + blockError = error; + throw error; + } finally { + scopeFinally(scope, blockError); + } + } + static withScopeMaybeAsync(_this, block) { + return (0, asyncify_helpers_1.maybeAsync)(void 0, function* (awaited) { + const scope = new Scope(); + let blockError; + try { + return yield* awaited.of(block.call(_this, awaited, scope)); + } catch (error) { + blockError = error; + throw error; + } finally { + scopeFinally(scope, blockError); + } + }); + } + /** + * Run `block` with a new Scope instance that will be disposed after the + * block's returned promise settles. Inside `block`, call `scope.manage` on each + * lifetime you create to have the lifetime automatically disposed after the + * block returns. + */ + static async withScopeAsync(block) { + const scope = new Scope(); + let blockError; + try { + return await block(scope); + } catch (error) { + blockError = error; + throw error; + } finally { + scopeFinally(scope, blockError); + } + } + /** + * Track `lifetime` so that it is disposed when this scope is disposed. + */ + manage(lifetime) { + this._disposables.value.add(lifetime); + return lifetime; + } + get alive() { + return this._disposables.alive; + } + dispose() { + const lifetimes = Array.from(this._disposables.value.values()).reverse(); + for (const lifetime of lifetimes) { + if (lifetime.alive) { + lifetime.dispose(); + } + } + this._disposables.dispose(); + } + }; + exports.Scope = Scope; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/deferred-promise.js +var require_deferred_promise = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/deferred-promise.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.QuickJSDeferredPromise = void 0; + var QuickJSDeferredPromise = class { + /** + * Use [[QuickJSContext.newPromise]] to create a new promise instead of calling + * this constructor directly. + * @unstable + */ + constructor(args) { + this.resolve = (value) => { + if (!this.resolveHandle.alive) { + return; + } + this.context.unwrapResult(this.context.callFunction(this.resolveHandle, this.context.undefined, value || this.context.undefined)).dispose(); + this.disposeResolvers(); + this.onSettled(); + }; + this.reject = (value) => { + if (!this.rejectHandle.alive) { + return; + } + this.context.unwrapResult(this.context.callFunction(this.rejectHandle, this.context.undefined, value || this.context.undefined)).dispose(); + this.disposeResolvers(); + this.onSettled(); + }; + this.dispose = () => { + if (this.handle.alive) { + this.handle.dispose(); + } + this.disposeResolvers(); + }; + this.context = args.context; + this.owner = args.context.runtime; + this.handle = args.promiseHandle; + this.settled = new Promise((resolve5) => { + this.onSettled = resolve5; + }); + this.resolveHandle = args.resolveHandle; + this.rejectHandle = args.rejectHandle; + } + get alive() { + return this.handle.alive || this.resolveHandle.alive || this.rejectHandle.alive; + } + disposeResolvers() { + if (this.resolveHandle.alive) { + this.resolveHandle.dispose(); + } + if (this.rejectHandle.alive) { + this.rejectHandle.dispose(); + } + } + }; + exports.QuickJSDeferredPromise = QuickJSDeferredPromise; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/memory.js +var require_memory = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/memory.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ModuleMemory = void 0; + var lifetime_1 = require_lifetime(); + var ModuleMemory = class { + constructor(module2) { + this.module = module2; + } + toPointerArray(handleArray) { + const typedArray = new Int32Array(handleArray.map((handle) => handle.value)); + const numBytes = typedArray.length * typedArray.BYTES_PER_ELEMENT; + const ptr = this.module._malloc(numBytes); + var heapBytes = new Uint8Array(this.module.HEAPU8.buffer, ptr, numBytes); + heapBytes.set(new Uint8Array(typedArray.buffer)); + return new lifetime_1.Lifetime(ptr, void 0, (ptr2) => this.module._free(ptr2)); + } + newMutablePointerArray(length) { + const zeros = new Int32Array(new Array(length).fill(0)); + const numBytes = zeros.length * zeros.BYTES_PER_ELEMENT; + const ptr = this.module._malloc(numBytes); + const typedArray = new Int32Array(this.module.HEAPU8.buffer, ptr, length); + typedArray.set(zeros); + return new lifetime_1.Lifetime({ typedArray, ptr }, void 0, (value) => this.module._free(value.ptr)); + } + newHeapCharPointer(string) { + const numBytes = this.module.lengthBytesUTF8(string) + 1; + const ptr = this.module._malloc(numBytes); + this.module.stringToUTF8(string, ptr, numBytes); + return new lifetime_1.Lifetime(ptr, void 0, (value) => this.module._free(value)); + } + consumeHeapCharPointer(ptr) { + const str = this.module.UTF8ToString(ptr); + this.module._free(ptr); + return str; + } + }; + exports.ModuleMemory = ModuleMemory; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/types-ffi.js +var require_types_ffi = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/types-ffi.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.EvalFlags = exports.assertSync = void 0; + function assertSync(fn) { + return function mustBeSync(...args) { + const result = fn(...args); + if (result && typeof result === "object" && result instanceof Promise) { + throw new Error("Function unexpectedly returned a Promise"); + } + return result; + }; + } + exports.assertSync = assertSync; + exports.EvalFlags = { + /** global code (default) */ + JS_EVAL_TYPE_GLOBAL: 0 << 0, + /** module code */ + JS_EVAL_TYPE_MODULE: 1 << 0, + /** direct call (internal use) */ + JS_EVAL_TYPE_DIRECT: 2 << 0, + /** indirect call (internal use) */ + JS_EVAL_TYPE_INDIRECT: 3 << 0, + JS_EVAL_TYPE_MASK: 3 << 0, + /** force 'strict' mode */ + JS_EVAL_FLAG_STRICT: 1 << 3, + /** force 'strip' mode */ + JS_EVAL_FLAG_STRIP: 1 << 4, + /** + * compile but do not run. The result is an object with a + * JS_TAG_FUNCTION_BYTECODE or JS_TAG_MODULE tag. It can be executed + * with JS_EvalFunction(). + */ + JS_EVAL_FLAG_COMPILE_ONLY: 1 << 5, + /** don't include the stack frames before this eval in the Error() backtraces */ + JS_EVAL_FLAG_BACKTRACE_BARRIER: 1 << 6 + }; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/types.js +var require_types2 = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/types.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.concat = exports.evalOptionsToFlags = exports.DefaultIntrinsics = void 0; + var types_ffi_1 = require_types_ffi(); + var UnstableSymbol = Symbol("Unstable"); + exports.DefaultIntrinsics = Symbol("DefaultIntrinsics"); + function evalOptionsToFlags(evalOptions) { + if (typeof evalOptions === "number") { + return evalOptions; + } + if (evalOptions === void 0) { + return 0; + } + const { type, strict, strip, compileOnly, backtraceBarrier } = evalOptions; + let flags = 0; + if (type === "global") + flags |= types_ffi_1.EvalFlags.JS_EVAL_TYPE_GLOBAL; + if (type === "module") + flags |= types_ffi_1.EvalFlags.JS_EVAL_TYPE_MODULE; + if (strict) + flags |= types_ffi_1.EvalFlags.JS_EVAL_FLAG_STRICT; + if (strip) + flags |= types_ffi_1.EvalFlags.JS_EVAL_FLAG_STRIP; + if (compileOnly) + flags |= types_ffi_1.EvalFlags.JS_EVAL_FLAG_COMPILE_ONLY; + if (backtraceBarrier) + flags |= types_ffi_1.EvalFlags.JS_EVAL_FLAG_BACKTRACE_BARRIER; + return flags; + } + exports.evalOptionsToFlags = evalOptionsToFlags; + function concat(...values) { + let result = []; + for (const value of values) { + if (value !== void 0) { + result = result.concat(value); + } + } + return result; + } + exports.concat = concat; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/context.js +var require_context = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/context.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.QuickJSContext = void 0; + var debug_1 = require_debug2(); + var deferred_promise_1 = require_deferred_promise(); + var errors_1 = require_errors(); + var lifetime_1 = require_lifetime(); + var memory_1 = require_memory(); + var types_1 = require_types2(); + var ContextMemory = class extends memory_1.ModuleMemory { + /** @private */ + constructor(args) { + super(args.module); + this.scope = new lifetime_1.Scope(); + this.copyJSValue = (ptr) => { + return this.ffi.QTS_DupValuePointer(this.ctx.value, ptr); + }; + this.freeJSValue = (ptr) => { + this.ffi.QTS_FreeValuePointer(this.ctx.value, ptr); + }; + args.ownedLifetimes?.forEach((lifetime) => this.scope.manage(lifetime)); + this.owner = args.owner; + this.module = args.module; + this.ffi = args.ffi; + this.rt = args.rt; + this.ctx = this.scope.manage(args.ctx); + } + get alive() { + return this.scope.alive; + } + dispose() { + return this.scope.dispose(); + } + /** + * Track `lifetime` so that it is disposed when this scope is disposed. + */ + manage(lifetime) { + return this.scope.manage(lifetime); + } + consumeJSCharPointer(ptr) { + const str = this.module.UTF8ToString(ptr); + this.ffi.QTS_FreeCString(this.ctx.value, ptr); + return str; + } + heapValueHandle(ptr) { + return new lifetime_1.Lifetime(ptr, this.copyJSValue, this.freeJSValue, this.owner); + } + }; + var QuickJSContext = class { + /** + * Use {@link QuickJS.createVm} to create a QuickJSContext instance. + */ + constructor(args) { + this._undefined = void 0; + this._null = void 0; + this._false = void 0; + this._true = void 0; + this._global = void 0; + this._BigInt = void 0; + this.fnNextId = -32768; + this.fnMaps = /* @__PURE__ */ new Map(); + this.cToHostCallbacks = { + callFunction: (ctx, this_ptr, argc, argv, fn_id) => { + if (ctx !== this.ctx.value) { + throw new Error("QuickJSContext instance received C -> JS call with mismatched ctx"); + } + const fn = this.getFunction(fn_id); + if (!fn) { + throw new Error(`QuickJSContext had no callback with id ${fn_id}`); + } + return lifetime_1.Scope.withScopeMaybeAsync(this, function* (awaited, scope) { + const thisHandle = scope.manage(new lifetime_1.WeakLifetime(this_ptr, this.memory.copyJSValue, this.memory.freeJSValue, this.runtime)); + const argHandles = new Array(argc); + for (let i = 0; i < argc; i++) { + const ptr = this.ffi.QTS_ArgvGetJSValueConstPointer(argv, i); + argHandles[i] = scope.manage(new lifetime_1.WeakLifetime(ptr, this.memory.copyJSValue, this.memory.freeJSValue, this.runtime)); + } + try { + const result = yield* awaited(fn.apply(thisHandle, argHandles)); + if (result) { + if ("error" in result && result.error) { + (0, debug_1.debugLog)("throw error", result.error); + throw result.error; + } + const handle = scope.manage(result instanceof lifetime_1.Lifetime ? result : result.value); + return this.ffi.QTS_DupValuePointer(this.ctx.value, handle.value); + } + return 0; + } catch (error) { + return this.errorToHandle(error).consume((errorHandle) => this.ffi.QTS_Throw(this.ctx.value, errorHandle.value)); + } + }); + } + }; + this.runtime = args.runtime; + this.module = args.module; + this.ffi = args.ffi; + this.rt = args.rt; + this.ctx = args.ctx; + this.memory = new ContextMemory({ + ...args, + owner: this.runtime + }); + args.callbacks.setContextCallbacks(this.ctx.value, this.cToHostCallbacks); + this.dump = this.dump.bind(this); + this.getString = this.getString.bind(this); + this.getNumber = this.getNumber.bind(this); + this.resolvePromise = this.resolvePromise.bind(this); + } + // @implement Disposable ---------------------------------------------------- + get alive() { + return this.memory.alive; + } + /** + * Dispose of this VM's underlying resources. + * + * @throws Calling this method without disposing of all created handles + * will result in an error. + */ + dispose() { + this.memory.dispose(); + } + // Globals ------------------------------------------------------------------ + /** + * [`undefined`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined). + */ + get undefined() { + if (this._undefined) { + return this._undefined; + } + const ptr = this.ffi.QTS_GetUndefined(); + return this._undefined = new lifetime_1.StaticLifetime(ptr); + } + /** + * [`null`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null). + */ + get null() { + if (this._null) { + return this._null; + } + const ptr = this.ffi.QTS_GetNull(); + return this._null = new lifetime_1.StaticLifetime(ptr); + } + /** + * [`true`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/true). + */ + get true() { + if (this._true) { + return this._true; + } + const ptr = this.ffi.QTS_GetTrue(); + return this._true = new lifetime_1.StaticLifetime(ptr); + } + /** + * [`false`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/false). + */ + get false() { + if (this._false) { + return this._false; + } + const ptr = this.ffi.QTS_GetFalse(); + return this._false = new lifetime_1.StaticLifetime(ptr); + } + /** + * [`global`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects). + * A handle to the global object inside the interpreter. + * You can set properties to create global variables. + */ + get global() { + if (this._global) { + return this._global; + } + const ptr = this.ffi.QTS_GetGlobalObject(this.ctx.value); + this.memory.manage(this.memory.heapValueHandle(ptr)); + this._global = new lifetime_1.StaticLifetime(ptr, this.runtime); + return this._global; + } + // New values --------------------------------------------------------------- + /** + * Converts a Javascript number into a QuickJS value. + */ + newNumber(num) { + return this.memory.heapValueHandle(this.ffi.QTS_NewFloat64(this.ctx.value, num)); + } + /** + * Create a QuickJS [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String) value. + */ + newString(str) { + const ptr = this.memory.newHeapCharPointer(str).consume((charHandle) => this.ffi.QTS_NewString(this.ctx.value, charHandle.value)); + return this.memory.heapValueHandle(ptr); + } + /** + * Create a QuickJS [symbol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol) value. + * No two symbols created with this function will be the same value. + */ + newUniqueSymbol(description) { + const key = (typeof description === "symbol" ? description.description : description) ?? ""; + const ptr = this.memory.newHeapCharPointer(key).consume((charHandle) => this.ffi.QTS_NewSymbol(this.ctx.value, charHandle.value, 0)); + return this.memory.heapValueHandle(ptr); + } + /** + * Get a symbol from the [global registry](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol#shared_symbols_in_the_global_symbol_registry) for the given key. + * All symbols created with the same key will be the same value. + */ + newSymbolFor(key) { + const description = (typeof key === "symbol" ? key.description : key) ?? ""; + const ptr = this.memory.newHeapCharPointer(description).consume((charHandle) => this.ffi.QTS_NewSymbol(this.ctx.value, charHandle.value, 1)); + return this.memory.heapValueHandle(ptr); + } + /** + * Create a QuickJS [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) value. + */ + newBigInt(num) { + if (!this._BigInt) { + const bigIntHandle2 = this.getProp(this.global, "BigInt"); + this.memory.manage(bigIntHandle2); + this._BigInt = new lifetime_1.StaticLifetime(bigIntHandle2.value, this.runtime); + } + const bigIntHandle = this._BigInt; + const asString = String(num); + return this.newString(asString).consume((handle) => this.unwrapResult(this.callFunction(bigIntHandle, this.undefined, handle))); + } + /** + * `{}`. + * Create a new QuickJS [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer). + * + * @param prototype - Like [`Object.create`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create). + */ + newObject(prototype) { + if (prototype) { + this.runtime.assertOwned(prototype); + } + const ptr = prototype ? this.ffi.QTS_NewObjectProto(this.ctx.value, prototype.value) : this.ffi.QTS_NewObject(this.ctx.value); + return this.memory.heapValueHandle(ptr); + } + /** + * `[]`. + * Create a new QuickJS [array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array). + */ + newArray() { + const ptr = this.ffi.QTS_NewArray(this.ctx.value); + return this.memory.heapValueHandle(ptr); + } + newPromise(value) { + const deferredPromise = lifetime_1.Scope.withScope((scope) => { + const mutablePointerArray = scope.manage(this.memory.newMutablePointerArray(2)); + const promisePtr = this.ffi.QTS_NewPromiseCapability(this.ctx.value, mutablePointerArray.value.ptr); + const promiseHandle = this.memory.heapValueHandle(promisePtr); + const [resolveHandle, rejectHandle] = Array.from(mutablePointerArray.value.typedArray).map((jsvaluePtr) => this.memory.heapValueHandle(jsvaluePtr)); + return new deferred_promise_1.QuickJSDeferredPromise({ + context: this, + promiseHandle, + resolveHandle, + rejectHandle + }); + }); + if (value && typeof value === "function") { + value = new Promise(value); + } + if (value) { + Promise.resolve(value).then(deferredPromise.resolve, (error) => error instanceof lifetime_1.Lifetime ? deferredPromise.reject(error) : this.newError(error).consume(deferredPromise.reject)); + } + return deferredPromise; + } + /** + * Convert a Javascript function into a QuickJS function value. + * See [[VmFunctionImplementation]] for more details. + * + * A [[VmFunctionImplementation]] should not free its arguments or its return + * value. A VmFunctionImplementation should also not retain any references to + * its return value. + * + * To implement an async function, create a promise with [[newPromise]], then + * return the deferred promise handle from `deferred.handle` from your + * function implementation: + * + * ``` + * const deferred = vm.newPromise() + * someNativeAsyncFunction().then(deferred.resolve) + * return deferred.handle + * ``` + */ + newFunction(name, fn) { + const fnId = ++this.fnNextId; + this.setFunction(fnId, fn); + return this.memory.heapValueHandle(this.ffi.QTS_NewFunction(this.ctx.value, fnId, name)); + } + newError(error) { + const errorHandle = this.memory.heapValueHandle(this.ffi.QTS_NewError(this.ctx.value)); + if (error && typeof error === "object") { + if (error.name !== void 0) { + this.newString(error.name).consume((handle) => this.setProp(errorHandle, "name", handle)); + } + if (error.message !== void 0) { + this.newString(error.message).consume((handle) => this.setProp(errorHandle, "message", handle)); + } + } else if (typeof error === "string") { + this.newString(error).consume((handle) => this.setProp(errorHandle, "message", handle)); + } else if (error !== void 0) { + this.newString(String(error)).consume((handle) => this.setProp(errorHandle, "message", handle)); + } + return errorHandle; + } + // Read values -------------------------------------------------------------- + /** + * `typeof` operator. **Not** [standards compliant](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof). + * + * @remarks + * Does not support BigInt values correctly. + */ + typeof(handle) { + this.runtime.assertOwned(handle); + return this.memory.consumeHeapCharPointer(this.ffi.QTS_Typeof(this.ctx.value, handle.value)); + } + /** + * Converts `handle` into a Javascript number. + * @returns `NaN` on error, otherwise a `number`. + */ + getNumber(handle) { + this.runtime.assertOwned(handle); + return this.ffi.QTS_GetFloat64(this.ctx.value, handle.value); + } + /** + * Converts `handle` to a Javascript string. + */ + getString(handle) { + this.runtime.assertOwned(handle); + return this.memory.consumeJSCharPointer(this.ffi.QTS_GetString(this.ctx.value, handle.value)); + } + /** + * Converts `handle` into a Javascript symbol. If the symbol is in the global + * registry in the guest, it will be created with Symbol.for on the host. + */ + getSymbol(handle) { + this.runtime.assertOwned(handle); + const key = this.memory.consumeJSCharPointer(this.ffi.QTS_GetSymbolDescriptionOrKey(this.ctx.value, handle.value)); + const isGlobal = this.ffi.QTS_IsGlobalSymbol(this.ctx.value, handle.value); + return isGlobal ? Symbol.for(key) : Symbol(key); + } + /** + * Converts `handle` to a Javascript bigint. + */ + getBigInt(handle) { + this.runtime.assertOwned(handle); + const asString = this.getString(handle); + return BigInt(asString); + } + /** + * `Promise.resolve(value)`. + * Convert a handle containing a Promise-like value inside the VM into an + * actual promise on the host. + * + * @remarks + * You may need to call [[executePendingJobs]] to ensure that the promise is resolved. + * + * @param promiseLikeHandle - A handle to a Promise-like value with a `.then(onSuccess, onError)` method. + */ + resolvePromise(promiseLikeHandle) { + this.runtime.assertOwned(promiseLikeHandle); + const vmResolveResult = lifetime_1.Scope.withScope((scope) => { + const vmPromise = scope.manage(this.getProp(this.global, "Promise")); + const vmPromiseResolve = scope.manage(this.getProp(vmPromise, "resolve")); + return this.callFunction(vmPromiseResolve, vmPromise, promiseLikeHandle); + }); + if (vmResolveResult.error) { + return Promise.resolve(vmResolveResult); + } + return new Promise((resolve5) => { + lifetime_1.Scope.withScope((scope) => { + const resolveHandle = scope.manage(this.newFunction("resolve", (value) => { + resolve5({ value: value && value.dup() }); + })); + const rejectHandle = scope.manage(this.newFunction("reject", (error) => { + resolve5({ error: error && error.dup() }); + })); + const promiseHandle = scope.manage(vmResolveResult.value); + const promiseThenHandle = scope.manage(this.getProp(promiseHandle, "then")); + this.unwrapResult(this.callFunction(promiseThenHandle, promiseHandle, resolveHandle, rejectHandle)).dispose(); + }); + }); + } + // Properties --------------------------------------------------------------- + /** + * `handle[key]`. + * Get a property from a JSValue. + * + * @param key - The property may be specified as a JSValue handle, or as a + * Javascript string (which will be converted automatically). + */ + getProp(handle, key) { + this.runtime.assertOwned(handle); + const ptr = this.borrowPropertyKey(key).consume((quickJSKey) => this.ffi.QTS_GetProp(this.ctx.value, handle.value, quickJSKey.value)); + const result = this.memory.heapValueHandle(ptr); + return result; + } + /** + * `handle[key] = value`. + * Set a property on a JSValue. + * + * @remarks + * Note that the QuickJS authors recommend using [[defineProp]] to define new + * properties. + * + * @param key - The property may be specified as a JSValue handle, or as a + * Javascript string or number (which will be converted automatically to a JSValue). + */ + setProp(handle, key, value) { + this.runtime.assertOwned(handle); + this.borrowPropertyKey(key).consume((quickJSKey) => this.ffi.QTS_SetProp(this.ctx.value, handle.value, quickJSKey.value, value.value)); + } + /** + * [`Object.defineProperty(handle, key, descriptor)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty). + * + * @param key - The property may be specified as a JSValue handle, or as a + * Javascript string or number (which will be converted automatically to a JSValue). + */ + defineProp(handle, key, descriptor) { + this.runtime.assertOwned(handle); + lifetime_1.Scope.withScope((scope) => { + const quickJSKey = scope.manage(this.borrowPropertyKey(key)); + const value = descriptor.value || this.undefined; + const configurable = Boolean(descriptor.configurable); + const enumerable = Boolean(descriptor.enumerable); + const hasValue = Boolean(descriptor.value); + const get = descriptor.get ? scope.manage(this.newFunction(descriptor.get.name, descriptor.get)) : this.undefined; + const set = descriptor.set ? scope.manage(this.newFunction(descriptor.set.name, descriptor.set)) : this.undefined; + this.ffi.QTS_DefineProp(this.ctx.value, handle.value, quickJSKey.value, value.value, get.value, set.value, configurable, enumerable, hasValue); + }); + } + // Evaluation --------------------------------------------------------------- + /** + * [`func.call(thisVal, ...args)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call). + * Call a JSValue as a function. + * + * See [[unwrapResult]], which will throw if the function returned an error, or + * return the result handle directly. If evaluation returned a handle containing + * a promise, use [[resolvePromise]] to convert it to a native promise and + * [[executePendingJobs]] to finish evaluating the promise. + * + * @returns A result. If the function threw synchronously, `result.error` be a + * handle to the exception. Otherwise `result.value` will be a handle to the + * value. + */ + callFunction(func, thisVal, ...args) { + this.runtime.assertOwned(func); + const resultPtr = this.memory.toPointerArray(args).consume((argsArrayPtr) => this.ffi.QTS_Call(this.ctx.value, func.value, thisVal.value, args.length, argsArrayPtr.value)); + const errorPtr = this.ffi.QTS_ResolveException(this.ctx.value, resultPtr); + if (errorPtr) { + this.ffi.QTS_FreeValuePointer(this.ctx.value, resultPtr); + return { error: this.memory.heapValueHandle(errorPtr) }; + } + return { value: this.memory.heapValueHandle(resultPtr) }; + } + /** + * Like [`eval(code)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval#Description). + * Evaluates the Javascript source `code` in the global scope of this VM. + * When working with async code, you many need to call [[executePendingJobs]] + * to execute callbacks pending after synchronous evaluation returns. + * + * See [[unwrapResult]], which will throw if the function returned an error, or + * return the result handle directly. If evaluation returned a handle containing + * a promise, use [[resolvePromise]] to convert it to a native promise and + * [[executePendingJobs]] to finish evaluating the promise. + * + * *Note*: to protect against infinite loops, provide an interrupt handler to + * [[setInterruptHandler]]. You can use [[shouldInterruptAfterDeadline]] to + * create a time-based deadline. + * + * @returns The last statement's value. If the code threw synchronously, + * `result.error` will be a handle to the exception. If execution was + * interrupted, the error will have name `InternalError` and message + * `interrupted`. + */ + evalCode(code, filename = "eval.js", options) { + const detectModule = options === void 0 ? 1 : 0; + const flags = (0, types_1.evalOptionsToFlags)(options); + const resultPtr = this.memory.newHeapCharPointer(code).consume((charHandle) => this.ffi.QTS_Eval(this.ctx.value, charHandle.value, filename, detectModule, flags)); + const errorPtr = this.ffi.QTS_ResolveException(this.ctx.value, resultPtr); + if (errorPtr) { + this.ffi.QTS_FreeValuePointer(this.ctx.value, resultPtr); + return { error: this.memory.heapValueHandle(errorPtr) }; + } + return { value: this.memory.heapValueHandle(resultPtr) }; + } + /** + * Throw an error in the VM, interrupted whatever current execution is in progress when execution resumes. + * @experimental + */ + throw(error) { + return this.errorToHandle(error).consume((handle) => this.ffi.QTS_Throw(this.ctx.value, handle.value)); + } + /** + * @private + */ + borrowPropertyKey(key) { + if (typeof key === "number") { + return this.newNumber(key); + } + if (typeof key === "string") { + return this.newString(key); + } + return new lifetime_1.StaticLifetime(key.value, this.runtime); + } + /** + * @private + */ + getMemory(rt) { + if (rt === this.rt.value) { + return this.memory; + } else { + throw new Error("Private API. Cannot get memory from a different runtime"); + } + } + // Utilities ---------------------------------------------------------------- + /** + * Dump a JSValue to Javascript in a best-effort fashion. + * Returns `handle.toString()` if it cannot be serialized to JSON. + */ + dump(handle) { + this.runtime.assertOwned(handle); + const type = this.typeof(handle); + if (type === "string") { + return this.getString(handle); + } else if (type === "number") { + return this.getNumber(handle); + } else if (type === "bigint") { + return this.getBigInt(handle); + } else if (type === "undefined") { + return void 0; + } else if (type === "symbol") { + return this.getSymbol(handle); + } + const str = this.memory.consumeJSCharPointer(this.ffi.QTS_Dump(this.ctx.value, handle.value)); + try { + return JSON.parse(str); + } catch (err) { + return str; + } + } + /** + * Unwrap a SuccessOrFail result such as a [[VmCallResult]] or a + * [[ExecutePendingJobsResult]], where the fail branch contains a handle to a QuickJS error value. + * If the result is a success, returns the value. + * If the result is an error, converts the error to a native object and throws the error. + */ + unwrapResult(result) { + if (result.error) { + const context = "context" in result.error ? result.error.context : this; + const cause = result.error.consume((error) => this.dump(error)); + if (cause && typeof cause === "object" && typeof cause.message === "string") { + const { message, name, stack } = cause; + const exception = new errors_1.QuickJSUnwrapError(""); + const hostStack = exception.stack; + if (typeof name === "string") { + exception.name = cause.name; + } + if (typeof stack === "string") { + exception.stack = `${name}: ${message} +${cause.stack}Host: ${hostStack}`; + } + Object.assign(exception, { cause, context, message }); + throw exception; + } + throw new errors_1.QuickJSUnwrapError(cause, context); + } + return result.value; + } + /** @private */ + getFunction(fn_id) { + const map_id = fn_id >> 8; + const fnMap = this.fnMaps.get(map_id); + if (!fnMap) { + return void 0; + } + return fnMap.get(fn_id); + } + /** @private */ + setFunction(fn_id, handle) { + const map_id = fn_id >> 8; + let fnMap = this.fnMaps.get(map_id); + if (!fnMap) { + fnMap = /* @__PURE__ */ new Map(); + this.fnMaps.set(map_id, fnMap); + } + return fnMap.set(fn_id, handle); + } + errorToHandle(error) { + if (error instanceof lifetime_1.Lifetime) { + return error; + } + return this.newError(error); + } + }; + exports.QuickJSContext = QuickJSContext; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/runtime.js +var require_runtime = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/runtime.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.QuickJSRuntime = void 0; + var asyncify_helpers_1 = require_asyncify_helpers(); + var context_1 = require_context(); + var debug_1 = require_debug2(); + var errors_1 = require_errors(); + var lifetime_1 = require_lifetime(); + var memory_1 = require_memory(); + var types_1 = require_types2(); + var QuickJSRuntime = class { + /** @private */ + constructor(args) { + this.scope = new lifetime_1.Scope(); + this.contextMap = /* @__PURE__ */ new Map(); + this.cToHostCallbacks = { + shouldInterrupt: (rt) => { + if (rt !== this.rt.value) { + throw new Error("QuickJSContext instance received C -> JS interrupt with mismatched rt"); + } + const fn = this.interruptHandler; + if (!fn) { + throw new Error("QuickJSContext had no interrupt handler"); + } + return fn(this) ? 1 : 0; + }, + loadModuleSource: (0, asyncify_helpers_1.maybeAsyncFn)(this, function* (awaited, rt, ctx, moduleName) { + const moduleLoader = this.moduleLoader; + if (!moduleLoader) { + throw new Error("Runtime has no module loader"); + } + if (rt !== this.rt.value) { + throw new Error("Runtime pointer mismatch"); + } + const context = this.contextMap.get(ctx) ?? this.newContext({ + contextPointer: ctx + }); + try { + const result = yield* awaited(moduleLoader(moduleName, context)); + if (typeof result === "object" && "error" in result && result.error) { + (0, debug_1.debugLog)("cToHostLoadModule: loader returned error", result.error); + throw result.error; + } + const moduleSource = typeof result === "string" ? result : "value" in result ? result.value : result; + return this.memory.newHeapCharPointer(moduleSource).value; + } catch (error) { + (0, debug_1.debugLog)("cToHostLoadModule: caught error", error); + context.throw(error); + return 0; + } + }), + normalizeModule: (0, asyncify_helpers_1.maybeAsyncFn)(this, function* (awaited, rt, ctx, baseModuleName, moduleNameRequest) { + const moduleNormalizer = this.moduleNormalizer; + if (!moduleNormalizer) { + throw new Error("Runtime has no module normalizer"); + } + if (rt !== this.rt.value) { + throw new Error("Runtime pointer mismatch"); + } + const context = this.contextMap.get(ctx) ?? this.newContext({ + /* TODO: Does this happen? Are we responsible for disposing? I don't think so */ + contextPointer: ctx + }); + try { + const result = yield* awaited(moduleNormalizer(baseModuleName, moduleNameRequest, context)); + if (typeof result === "object" && "error" in result && result.error) { + (0, debug_1.debugLog)("cToHostNormalizeModule: normalizer returned error", result.error); + throw result.error; + } + const name = typeof result === "string" ? result : result.value; + return context.getMemory(this.rt.value).newHeapCharPointer(name).value; + } catch (error) { + (0, debug_1.debugLog)("normalizeModule: caught error", error); + context.throw(error); + return 0; + } + }) + }; + args.ownedLifetimes?.forEach((lifetime) => this.scope.manage(lifetime)); + this.module = args.module; + this.memory = new memory_1.ModuleMemory(this.module); + this.ffi = args.ffi; + this.rt = args.rt; + this.callbacks = args.callbacks; + this.scope.manage(this.rt); + this.callbacks.setRuntimeCallbacks(this.rt.value, this.cToHostCallbacks); + this.executePendingJobs = this.executePendingJobs.bind(this); + } + get alive() { + return this.scope.alive; + } + dispose() { + return this.scope.dispose(); + } + newContext(options = {}) { + if (options.intrinsics && options.intrinsics !== types_1.DefaultIntrinsics) { + throw new Error("TODO: Custom intrinsics are not supported yet"); + } + const ctx = new lifetime_1.Lifetime(options.contextPointer || this.ffi.QTS_NewContext(this.rt.value), void 0, (ctx_ptr) => { + this.contextMap.delete(ctx_ptr); + this.callbacks.deleteContext(ctx_ptr); + this.ffi.QTS_FreeContext(ctx_ptr); + }); + const context = new context_1.QuickJSContext({ + module: this.module, + ctx, + ffi: this.ffi, + rt: this.rt, + ownedLifetimes: options.ownedLifetimes, + runtime: this, + callbacks: this.callbacks + }); + this.contextMap.set(ctx.value, context); + return context; + } + /** + * Set the loader for EcmaScript modules requested by any context in this + * runtime. + * + * The loader can be removed with [[removeModuleLoader]]. + */ + setModuleLoader(moduleLoader, moduleNormalizer) { + this.moduleLoader = moduleLoader; + this.moduleNormalizer = moduleNormalizer; + this.ffi.QTS_RuntimeEnableModuleLoader(this.rt.value, this.moduleNormalizer ? 1 : 0); + } + /** + * Remove the the loader set by [[setModuleLoader]]. This disables module loading. + */ + removeModuleLoader() { + this.moduleLoader = void 0; + this.ffi.QTS_RuntimeDisableModuleLoader(this.rt.value); + } + // Runtime management ------------------------------------------------------- + /** + * In QuickJS, promises and async functions create pendingJobs. These do not execute + * immediately and need to be run by calling [[executePendingJobs]]. + * + * @return true if there is at least one pendingJob queued up. + */ + hasPendingJob() { + return Boolean(this.ffi.QTS_IsJobPending(this.rt.value)); + } + /** + * Set a callback which is regularly called by the QuickJS engine when it is + * executing code. This callback can be used to implement an execution + * timeout. + * + * The interrupt handler can be removed with [[removeInterruptHandler]]. + */ + setInterruptHandler(cb) { + const prevInterruptHandler = this.interruptHandler; + this.interruptHandler = cb; + if (!prevInterruptHandler) { + this.ffi.QTS_RuntimeEnableInterruptHandler(this.rt.value); + } + } + /** + * Remove the interrupt handler, if any. + * See [[setInterruptHandler]]. + */ + removeInterruptHandler() { + if (this.interruptHandler) { + this.ffi.QTS_RuntimeDisableInterruptHandler(this.rt.value); + this.interruptHandler = void 0; + } + } + /** + * Execute pendingJobs on the runtime until `maxJobsToExecute` jobs are + * executed (default all pendingJobs), the queue is exhausted, or the runtime + * encounters an exception. + * + * In QuickJS, promises and async functions *inside the runtime* create + * pendingJobs. These do not execute immediately and need to triggered to run. + * + * @param maxJobsToExecute - When negative, run all pending jobs. Otherwise execute + * at most `maxJobsToExecute` before returning. + * + * @return On success, the number of executed jobs. On error, the exception + * that stopped execution, and the context it occurred in. Note that + * executePendingJobs will not normally return errors thrown inside async + * functions or rejected promises. Those errors are available by calling + * [[resolvePromise]] on the promise handle returned by the async function. + */ + executePendingJobs(maxJobsToExecute = -1) { + const ctxPtrOut = this.memory.newMutablePointerArray(1); + const valuePtr = this.ffi.QTS_ExecutePendingJob(this.rt.value, maxJobsToExecute ?? -1, ctxPtrOut.value.ptr); + const ctxPtr = ctxPtrOut.value.typedArray[0]; + ctxPtrOut.dispose(); + if (ctxPtr === 0) { + this.ffi.QTS_FreeValuePointerRuntime(this.rt.value, valuePtr); + return { value: 0 }; + } + const context = this.contextMap.get(ctxPtr) ?? this.newContext({ + contextPointer: ctxPtr + }); + const resultValue = context.getMemory(this.rt.value).heapValueHandle(valuePtr); + const typeOfRet = context.typeof(resultValue); + if (typeOfRet === "number") { + const executedJobs = context.getNumber(resultValue); + resultValue.dispose(); + return { value: executedJobs }; + } else { + const error = Object.assign(resultValue, { context }); + return { + error + }; + } + } + /** + * Set the max memory this runtime can allocate. + * To remove the limit, set to `-1`. + */ + setMemoryLimit(limitBytes) { + if (limitBytes < 0 && limitBytes !== -1) { + throw new Error("Cannot set memory limit to negative number. To unset, pass -1"); + } + this.ffi.QTS_RuntimeSetMemoryLimit(this.rt.value, limitBytes); + } + /** + * Compute memory usage for this runtime. Returns the result as a handle to a + * JSValue object. Use [[QuickJSContext.dump]] to convert to a native object. + * Calling this method will allocate more memory inside the runtime. The information + * is accurate as of just before the call to `computeMemoryUsage`. + * For a human-digestible representation, see [[dumpMemoryUsage]]. + */ + computeMemoryUsage() { + const serviceContextMemory = this.getSystemContext().getMemory(this.rt.value); + return serviceContextMemory.heapValueHandle(this.ffi.QTS_RuntimeComputeMemoryUsage(this.rt.value, serviceContextMemory.ctx.value)); + } + /** + * @returns a human-readable description of memory usage in this runtime. + * For programmatic access to this information, see [[computeMemoryUsage]]. + */ + dumpMemoryUsage() { + return this.memory.consumeHeapCharPointer(this.ffi.QTS_RuntimeDumpMemoryUsage(this.rt.value)); + } + /** + * Set the max stack size for this runtime, in bytes. + * To remove the limit, set to `0`. + */ + setMaxStackSize(stackSize) { + if (stackSize < 0) { + throw new Error("Cannot set memory limit to negative number. To unset, pass 0."); + } + this.ffi.QTS_RuntimeSetMaxStackSize(this.rt.value, stackSize); + } + /** + * Assert that `handle` is owned by this runtime. + * @throws QuickJSWrongOwner if owned by a different runtime. + */ + assertOwned(handle) { + if (handle.owner && handle.owner.rt !== this.rt) { + throw new errors_1.QuickJSWrongOwner(`Handle is not owned by this runtime: ${handle.owner.rt.value} != ${this.rt.value}`); + } + } + getSystemContext() { + if (!this.context) { + this.context = this.scope.manage(this.newContext()); + } + return this.context; + } + }; + exports.QuickJSRuntime = QuickJSRuntime; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/module.js +var require_module = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/module.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.QuickJSWASMModule = exports.applyModuleEvalRuntimeOptions = exports.applyBaseRuntimeOptions = exports.QuickJSModuleCallbacks = void 0; + var debug_1 = require_debug2(); + var errors_1 = require_errors(); + var lifetime_1 = require_lifetime(); + var runtime_1 = require_runtime(); + var types_1 = require_types2(); + var QuickJSEmscriptenModuleCallbacks = class { + constructor(args) { + this.callFunction = args.callFunction; + this.shouldInterrupt = args.shouldInterrupt; + this.loadModuleSource = args.loadModuleSource; + this.normalizeModule = args.normalizeModule; + } + }; + var QuickJSModuleCallbacks = class { + constructor(module2) { + this.contextCallbacks = /* @__PURE__ */ new Map(); + this.runtimeCallbacks = /* @__PURE__ */ new Map(); + this.suspendedCount = 0; + this.cToHostCallbacks = new QuickJSEmscriptenModuleCallbacks({ + callFunction: (asyncify, ctx, this_ptr, argc, argv, fn_id) => this.handleAsyncify(asyncify, () => { + try { + const vm = this.contextCallbacks.get(ctx); + if (!vm) { + throw new Error(`QuickJSContext(ctx = ${ctx}) not found for C function call "${fn_id}"`); + } + return vm.callFunction(ctx, this_ptr, argc, argv, fn_id); + } catch (error) { + console.error("[C to host error: returning null]", error); + return 0; + } + }), + shouldInterrupt: (asyncify, rt) => this.handleAsyncify(asyncify, () => { + try { + const vm = this.runtimeCallbacks.get(rt); + if (!vm) { + throw new Error(`QuickJSRuntime(rt = ${rt}) not found for C interrupt`); + } + return vm.shouldInterrupt(rt); + } catch (error) { + console.error("[C to host interrupt: returning error]", error); + return 1; + } + }), + loadModuleSource: (asyncify, rt, ctx, moduleName) => this.handleAsyncify(asyncify, () => { + try { + const runtimeCallbacks = this.runtimeCallbacks.get(rt); + if (!runtimeCallbacks) { + throw new Error(`QuickJSRuntime(rt = ${rt}) not found for C module loader`); + } + const loadModule = runtimeCallbacks.loadModuleSource; + if (!loadModule) { + throw new Error(`QuickJSRuntime(rt = ${rt}) does not support module loading`); + } + return loadModule(rt, ctx, moduleName); + } catch (error) { + console.error("[C to host module loader error: returning null]", error); + return 0; + } + }), + normalizeModule: (asyncify, rt, ctx, moduleBaseName, moduleName) => this.handleAsyncify(asyncify, () => { + try { + const runtimeCallbacks = this.runtimeCallbacks.get(rt); + if (!runtimeCallbacks) { + throw new Error(`QuickJSRuntime(rt = ${rt}) not found for C module loader`); + } + const normalizeModule = runtimeCallbacks.normalizeModule; + if (!normalizeModule) { + throw new Error(`QuickJSRuntime(rt = ${rt}) does not support module loading`); + } + return normalizeModule(rt, ctx, moduleBaseName, moduleName); + } catch (error) { + console.error("[C to host module loader error: returning null]", error); + return 0; + } + }) + }); + this.module = module2; + this.module.callbacks = this.cToHostCallbacks; + } + setRuntimeCallbacks(rt, callbacks) { + this.runtimeCallbacks.set(rt, callbacks); + } + deleteRuntime(rt) { + this.runtimeCallbacks.delete(rt); + } + setContextCallbacks(ctx, callbacks) { + this.contextCallbacks.set(ctx, callbacks); + } + deleteContext(ctx) { + this.contextCallbacks.delete(ctx); + } + handleAsyncify(asyncify, fn) { + if (asyncify) { + return asyncify.handleSleep((done) => { + try { + const result = fn(); + if (!(result instanceof Promise)) { + (0, debug_1.debugLog)("asyncify.handleSleep: not suspending:", result); + done(result); + return; + } + if (this.suspended) { + throw new errors_1.QuickJSAsyncifyError(`Already suspended at: ${this.suspended.stack} +Attempted to suspend at:`); + } else { + this.suspended = new errors_1.QuickJSAsyncifySuspended(`(${this.suspendedCount++})`); + (0, debug_1.debugLog)("asyncify.handleSleep: suspending:", this.suspended); + } + result.then((resolvedResult) => { + this.suspended = void 0; + (0, debug_1.debugLog)("asyncify.handleSleep: resolved:", resolvedResult); + done(resolvedResult); + }, (error) => { + (0, debug_1.debugLog)("asyncify.handleSleep: rejected:", error); + console.error("QuickJS: cannot handle error in suspended function", error); + this.suspended = void 0; + }); + } catch (error) { + (0, debug_1.debugLog)("asyncify.handleSleep: error:", error); + this.suspended = void 0; + throw error; + } + }); + } + const value = fn(); + if (value instanceof Promise) { + throw new Error("Promise return value not supported in non-asyncify context."); + } + return value; + } + }; + exports.QuickJSModuleCallbacks = QuickJSModuleCallbacks; + function applyBaseRuntimeOptions(runtime, options) { + if (options.interruptHandler) { + runtime.setInterruptHandler(options.interruptHandler); + } + if (options.maxStackSizeBytes !== void 0) { + runtime.setMaxStackSize(options.maxStackSizeBytes); + } + if (options.memoryLimitBytes !== void 0) { + runtime.setMemoryLimit(options.memoryLimitBytes); + } + } + exports.applyBaseRuntimeOptions = applyBaseRuntimeOptions; + function applyModuleEvalRuntimeOptions(runtime, options) { + if (options.moduleLoader) { + runtime.setModuleLoader(options.moduleLoader); + } + if (options.shouldInterrupt) { + runtime.setInterruptHandler(options.shouldInterrupt); + } + if (options.memoryLimitBytes !== void 0) { + runtime.setMemoryLimit(options.memoryLimitBytes); + } + if (options.maxStackSizeBytes !== void 0) { + runtime.setMaxStackSize(options.maxStackSizeBytes); + } + } + exports.applyModuleEvalRuntimeOptions = applyModuleEvalRuntimeOptions; + var QuickJSWASMModule = class { + /** @private */ + constructor(module2, ffi) { + this.module = module2; + this.ffi = ffi; + this.callbacks = new QuickJSModuleCallbacks(module2); + } + /** + * Create a runtime. + * Use the runtime to set limits on CPU and memory usage and configure module + * loading for one or more [[QuickJSContext]]s inside the runtime. + */ + newRuntime(options = {}) { + const rt = new lifetime_1.Lifetime(this.ffi.QTS_NewRuntime(), void 0, (rt_ptr) => { + this.callbacks.deleteRuntime(rt_ptr); + this.ffi.QTS_FreeRuntime(rt_ptr); + }); + const runtime = new runtime_1.QuickJSRuntime({ + module: this.module, + callbacks: this.callbacks, + ffi: this.ffi, + rt + }); + applyBaseRuntimeOptions(runtime, options); + if (options.moduleLoader) { + runtime.setModuleLoader(options.moduleLoader); + } + return runtime; + } + /** + * A simplified API to create a new [[QuickJSRuntime]] and a + * [[QuickJSContext]] inside that runtime at the same time. The runtime will + * be disposed when the context is disposed. + */ + newContext(options = {}) { + const runtime = this.newRuntime(); + const context = runtime.newContext({ + ...options, + ownedLifetimes: (0, types_1.concat)(runtime, options.ownedLifetimes) + }); + runtime.context = context; + return context; + } + /** + * One-off evaluate code without needing to create a [[QuickJSRuntime]] or + * [[QuickJSContext]] explicitly. + * + * To protect against infinite loops, use the `shouldInterrupt` option. The + * [[shouldInterruptAfterDeadline]] function will create a time-based deadline. + * + * If you need more control over how the code executes, create a + * [[QuickJSRuntime]] (with [[newRuntime]]) or a [[QuickJSContext]] (with + * [[newContext]] or [[QuickJSRuntime.newContext]]), and use its + * [[QuickJSContext.evalCode]] method. + * + * Asynchronous callbacks may not run during the first call to `evalCode`. If + * you need to work with async code inside QuickJS, create a runtime and use + * [[QuickJSRuntime.executePendingJobs]]. + * + * @returns The result is coerced to a native Javascript value using JSON + * serialization, so properties and values unsupported by JSON will be dropped. + * + * @throws If `code` throws during evaluation, the exception will be + * converted into a native Javascript value and thrown. + * + * @throws if `options.shouldInterrupt` interrupted execution, will throw a Error + * with name `"InternalError"` and message `"interrupted"`. + */ + evalCode(code, options = {}) { + return lifetime_1.Scope.withScope((scope) => { + const vm = scope.manage(this.newContext()); + applyModuleEvalRuntimeOptions(vm.runtime, options); + const result = vm.evalCode(code, "eval.js"); + if (options.memoryLimitBytes !== void 0) { + vm.runtime.setMemoryLimit(-1); + } + if (result.error) { + const error = vm.dump(scope.manage(result.error)); + throw error; + } + const value = vm.dump(scope.manage(result.value)); + return value; + }); + } + /** + * Get a low-level interface to the QuickJS functions in this WebAssembly + * module. + * @experimental + * @unstable No warranty is provided with this API. It could change at any time. + * @private + */ + getFFI() { + return this.ffi; + } + }; + exports.QuickJSWASMModule = QuickJSWASMModule; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/context-asyncify.js +var require_context_asyncify = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/context-asyncify.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.QuickJSAsyncContext = void 0; + var context_1 = require_context(); + var debug_1 = require_debug2(); + var types_1 = require_types2(); + var QuickJSAsyncContext = class extends context_1.QuickJSContext { + /** + * Asyncified version of [[evalCode]]. + */ + async evalCodeAsync(code, filename = "eval.js", options) { + const detectModule = options === void 0 ? 1 : 0; + const flags = (0, types_1.evalOptionsToFlags)(options); + let resultPtr = 0; + try { + resultPtr = await this.memory.newHeapCharPointer(code).consume((charHandle) => this.ffi.QTS_Eval_MaybeAsync(this.ctx.value, charHandle.value, filename, detectModule, flags)); + } catch (error) { + (0, debug_1.debugLog)("QTS_Eval_MaybeAsync threw", error); + throw error; + } + const errorPtr = this.ffi.QTS_ResolveException(this.ctx.value, resultPtr); + if (errorPtr) { + this.ffi.QTS_FreeValuePointer(this.ctx.value, resultPtr); + return { error: this.memory.heapValueHandle(errorPtr) }; + } + return { value: this.memory.heapValueHandle(resultPtr) }; + } + /** + * Similar to [[newFunction]]. + * Convert an async host Javascript function into a synchronous QuickJS function value. + * + * Whenever QuickJS calls this function, the VM's stack will be unwound while + * waiting the async function to complete, and then restored when the returned + * promise resolves. + * + * Asyncified functions must never call other asyncified functions or + * `import`, even indirectly, because the stack cannot be unwound twice. + * + * See [Emscripten's docs on Asyncify](https://emscripten.org/docs/porting/asyncify.html). + */ + newAsyncifiedFunction(name, fn) { + return this.newFunction(name, fn); + } + }; + exports.QuickJSAsyncContext = QuickJSAsyncContext; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/runtime-asyncify.js +var require_runtime_asyncify = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/runtime-asyncify.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.QuickJSAsyncRuntime = void 0; + var _1 = require_dist9(); + var context_asyncify_1 = require_context_asyncify(); + var runtime_1 = require_runtime(); + var types_1 = require_types2(); + var QuickJSAsyncRuntime = class extends runtime_1.QuickJSRuntime { + /** @private */ + constructor(args) { + super(args); + } + newContext(options = {}) { + if (options.intrinsics && options.intrinsics !== types_1.DefaultIntrinsics) { + throw new Error("TODO: Custom intrinsics are not supported yet"); + } + const ctx = new _1.Lifetime(this.ffi.QTS_NewContext(this.rt.value), void 0, (ctx_ptr) => { + this.contextMap.delete(ctx_ptr); + this.callbacks.deleteContext(ctx_ptr); + this.ffi.QTS_FreeContext(ctx_ptr); + }); + const context = new context_asyncify_1.QuickJSAsyncContext({ + module: this.module, + ctx, + ffi: this.ffi, + rt: this.rt, + ownedLifetimes: [], + runtime: this, + callbacks: this.callbacks + }); + this.contextMap.set(ctx.value, context); + return context; + } + setModuleLoader(moduleLoader, moduleNormalizer) { + super.setModuleLoader(moduleLoader, moduleNormalizer); + } + /** + * Set the max stack size for this runtime in bytes. + * To remove the limit, set to `0`. + * + * Setting this limit also adjusts the global `ASYNCIFY_STACK_SIZE` for the entire {@link QuickJSAsyncWASMModule}. + * See the [pull request](https://github.com/justjake/quickjs-emscripten/pull/114) for more details. + */ + setMaxStackSize(stackSize) { + return super.setMaxStackSize(stackSize); + } + }; + exports.QuickJSAsyncRuntime = QuickJSAsyncRuntime; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/module-asyncify.js +var require_module_asyncify = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/module-asyncify.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.QuickJSAsyncWASMModule = void 0; + var errors_1 = require_errors(); + var lifetime_1 = require_lifetime(); + var module_1 = require_module(); + var runtime_asyncify_1 = require_runtime_asyncify(); + var QuickJSAsyncWASMModule = class extends module_1.QuickJSWASMModule { + /** @private */ + constructor(module2, ffi) { + super(module2, ffi); + this.ffi = ffi; + this.module = module2; + } + /** + * Create a new async runtime inside this WebAssembly module. All runtimes inside a + * module are limited to a single async call at a time. For multiple + * concurrent async actions, create multiple WebAssembly modules. + */ + newRuntime(options = {}) { + const rt = new lifetime_1.Lifetime(this.ffi.QTS_NewRuntime(), void 0, (rt_ptr) => { + this.callbacks.deleteRuntime(rt_ptr); + this.ffi.QTS_FreeRuntime(rt_ptr); + }); + const runtime = new runtime_asyncify_1.QuickJSAsyncRuntime({ + module: this.module, + ffi: this.ffi, + rt, + callbacks: this.callbacks + }); + (0, module_1.applyBaseRuntimeOptions)(runtime, options); + if (options.moduleLoader) { + runtime.setModuleLoader(options.moduleLoader); + } + return runtime; + } + /** + * A simplified API to create a new [[QuickJSRuntime]] and a + * [[QuickJSContext]] inside that runtime at the same time. The runtime will + * be disposed when the context is disposed. + */ + newContext(options = {}) { + const runtime = this.newRuntime(); + const lifetimes = options.ownedLifetimes ? options.ownedLifetimes.concat([runtime]) : [runtime]; + const context = runtime.newContext({ ...options, ownedLifetimes: lifetimes }); + runtime.context = context; + return context; + } + /** Synchronous evalCode is not supported. */ + evalCode() { + throw new errors_1.QuickJSNotImplemented("QuickJSWASMModuleAsyncify.evalCode: use evalCodeAsync instead"); + } + /** + * One-off evaluate code without needing to create a [[QuickJSRuntimeAsync]] or + * [[QuickJSContextSync]] explicitly. + * + * This version allows for asynchronous Ecmascript module loading. + * + * Note that only a single async action can occur at a time inside the entire WebAssembly module. + * **Multiple concurrent async actions is an error.** + * + * See the documentation for [[QuickJSWASMModule.evalCode]] for more details. + */ + evalCodeAsync(code, options) { + return lifetime_1.Scope.withScopeAsync(async (scope) => { + const vm = scope.manage(this.newContext()); + (0, module_1.applyModuleEvalRuntimeOptions)(vm.runtime, options); + const result = await vm.evalCodeAsync(code, "eval.js"); + if (options.memoryLimitBytes !== void 0) { + vm.runtime.setMemoryLimit(-1); + } + if (result.error) { + const error = vm.dump(scope.manage(result.error)); + throw error; + } + const value = vm.dump(scope.manage(result.value)); + return value; + }); + } + }; + exports.QuickJSAsyncWASMModule = QuickJSAsyncWASMModule; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/generated/ffi.WASM_RELEASE_SYNC.js +var require_ffi_WASM_RELEASE_SYNC = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/generated/ffi.WASM_RELEASE_SYNC.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.QuickJSFFI = void 0; + var QuickJSFFI = class { + constructor(module2) { + this.module = module2; + this.DEBUG = false; + this.QTS_Throw = this.module.cwrap("QTS_Throw", "number", ["number", "number"]); + this.QTS_NewError = this.module.cwrap("QTS_NewError", "number", ["number"]); + this.QTS_RuntimeSetMemoryLimit = this.module.cwrap("QTS_RuntimeSetMemoryLimit", null, ["number", "number"]); + this.QTS_RuntimeComputeMemoryUsage = this.module.cwrap("QTS_RuntimeComputeMemoryUsage", "number", ["number", "number"]); + this.QTS_RuntimeDumpMemoryUsage = this.module.cwrap("QTS_RuntimeDumpMemoryUsage", "number", ["number"]); + this.QTS_RecoverableLeakCheck = this.module.cwrap("QTS_RecoverableLeakCheck", "number", []); + this.QTS_BuildIsSanitizeLeak = this.module.cwrap("QTS_BuildIsSanitizeLeak", "number", []); + this.QTS_RuntimeSetMaxStackSize = this.module.cwrap("QTS_RuntimeSetMaxStackSize", null, ["number", "number"]); + this.QTS_GetUndefined = this.module.cwrap("QTS_GetUndefined", "number", []); + this.QTS_GetNull = this.module.cwrap("QTS_GetNull", "number", []); + this.QTS_GetFalse = this.module.cwrap("QTS_GetFalse", "number", []); + this.QTS_GetTrue = this.module.cwrap("QTS_GetTrue", "number", []); + this.QTS_NewRuntime = this.module.cwrap("QTS_NewRuntime", "number", []); + this.QTS_FreeRuntime = this.module.cwrap("QTS_FreeRuntime", null, ["number"]); + this.QTS_NewContext = this.module.cwrap("QTS_NewContext", "number", ["number"]); + this.QTS_FreeContext = this.module.cwrap("QTS_FreeContext", null, ["number"]); + this.QTS_FreeValuePointer = this.module.cwrap("QTS_FreeValuePointer", null, ["number", "number"]); + this.QTS_FreeValuePointerRuntime = this.module.cwrap("QTS_FreeValuePointerRuntime", null, ["number", "number"]); + this.QTS_FreeVoidPointer = this.module.cwrap("QTS_FreeVoidPointer", null, ["number", "number"]); + this.QTS_FreeCString = this.module.cwrap("QTS_FreeCString", null, ["number", "number"]); + this.QTS_DupValuePointer = this.module.cwrap("QTS_DupValuePointer", "number", ["number", "number"]); + this.QTS_NewObject = this.module.cwrap("QTS_NewObject", "number", ["number"]); + this.QTS_NewObjectProto = this.module.cwrap("QTS_NewObjectProto", "number", ["number", "number"]); + this.QTS_NewArray = this.module.cwrap("QTS_NewArray", "number", ["number"]); + this.QTS_NewFloat64 = this.module.cwrap("QTS_NewFloat64", "number", ["number", "number"]); + this.QTS_GetFloat64 = this.module.cwrap("QTS_GetFloat64", "number", ["number", "number"]); + this.QTS_NewString = this.module.cwrap("QTS_NewString", "number", ["number", "number"]); + this.QTS_GetString = this.module.cwrap("QTS_GetString", "number", ["number", "number"]); + this.QTS_NewSymbol = this.module.cwrap("QTS_NewSymbol", "number", ["number", "number", "number"]); + this.QTS_GetSymbolDescriptionOrKey = this.module.cwrap("QTS_GetSymbolDescriptionOrKey", "number", ["number", "number"]); + this.QTS_IsGlobalSymbol = this.module.cwrap("QTS_IsGlobalSymbol", "number", ["number", "number"]); + this.QTS_IsJobPending = this.module.cwrap("QTS_IsJobPending", "number", ["number"]); + this.QTS_ExecutePendingJob = this.module.cwrap("QTS_ExecutePendingJob", "number", ["number", "number", "number"]); + this.QTS_GetProp = this.module.cwrap("QTS_GetProp", "number", ["number", "number", "number"]); + this.QTS_SetProp = this.module.cwrap("QTS_SetProp", null, ["number", "number", "number", "number"]); + this.QTS_DefineProp = this.module.cwrap("QTS_DefineProp", null, ["number", "number", "number", "number", "number", "number", "boolean", "boolean", "boolean"]); + this.QTS_Call = this.module.cwrap("QTS_Call", "number", ["number", "number", "number", "number", "number"]); + this.QTS_ResolveException = this.module.cwrap("QTS_ResolveException", "number", ["number", "number"]); + this.QTS_Dump = this.module.cwrap("QTS_Dump", "number", ["number", "number"]); + this.QTS_Eval = this.module.cwrap("QTS_Eval", "number", ["number", "number", "string", "number", "number"]); + this.QTS_Typeof = this.module.cwrap("QTS_Typeof", "number", ["number", "number"]); + this.QTS_GetGlobalObject = this.module.cwrap("QTS_GetGlobalObject", "number", ["number"]); + this.QTS_NewPromiseCapability = this.module.cwrap("QTS_NewPromiseCapability", "number", ["number", "number"]); + this.QTS_TestStringArg = this.module.cwrap("QTS_TestStringArg", null, ["string"]); + this.QTS_BuildIsDebug = this.module.cwrap("QTS_BuildIsDebug", "number", []); + this.QTS_BuildIsAsyncify = this.module.cwrap("QTS_BuildIsAsyncify", "number", []); + this.QTS_NewFunction = this.module.cwrap("QTS_NewFunction", "number", ["number", "number", "string"]); + this.QTS_ArgvGetJSValueConstPointer = this.module.cwrap("QTS_ArgvGetJSValueConstPointer", "number", ["number", "number"]); + this.QTS_RuntimeEnableInterruptHandler = this.module.cwrap("QTS_RuntimeEnableInterruptHandler", null, ["number"]); + this.QTS_RuntimeDisableInterruptHandler = this.module.cwrap("QTS_RuntimeDisableInterruptHandler", null, ["number"]); + this.QTS_RuntimeEnableModuleLoader = this.module.cwrap("QTS_RuntimeEnableModuleLoader", null, ["number", "number"]); + this.QTS_RuntimeDisableModuleLoader = this.module.cwrap("QTS_RuntimeDisableModuleLoader", null, ["number"]); + } + }; + exports.QuickJSFFI = QuickJSFFI; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/generated/emscripten-module.WASM_RELEASE_SYNC.js +var require_emscripten_module_WASM_RELEASE_SYNC = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/generated/emscripten-module.WASM_RELEASE_SYNC.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var QuickJSRaw = (() => { + var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : void 0; + if (typeof __filename !== "undefined") + _scriptDir = _scriptDir || __filename; + return function(QuickJSRaw2 = {}) { + var a; + a || (a = typeof QuickJSRaw2 !== "undefined" ? QuickJSRaw2 : {}); + var m, n; + a.ready = new Promise(function(b, c) { + m = b; + n = c; + }); + var p = Object.assign({}, a), t = "./this.program", u = "object" == typeof window, v = "function" == typeof importScripts, w = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, x = "", y, z, A; + if (w) { + var fs6 = __require("fs"), B = __require("path"); + x = v ? B.dirname(x) + "/" : __dirname + "/"; + y = (b, c) => { + var d = C(b); + if (d) + return c ? d : d.toString(); + b = b.startsWith("file://") ? new URL(b) : B.normalize(b); + return fs6.readFileSync(b, c ? void 0 : "utf8"); + }; + A = (b) => { + b = y(b, true); + b.buffer || (b = new Uint8Array(b)); + return b; + }; + z = (b, c, d) => { + var e = C(b); + e && c(e); + b = b.startsWith("file://") ? new URL(b) : B.normalize(b); + fs6.readFile(b, function(f, g) { + f ? d(f) : c(g.buffer); + }); + }; + !a.thisProgram && 1 < process.argv.length && (t = process.argv[1].replace(/\\/g, "/")); + process.argv.slice(2); + a.inspect = function() { + return "[Emscripten Module object]"; + }; + } else if (u || v) + v ? x = self.location.href : "undefined" != typeof document && document.currentScript && (x = document.currentScript.src), _scriptDir && (x = _scriptDir), 0 !== x.indexOf("blob:") ? x = x.substr(0, x.replace(/[?#].*/, "").lastIndexOf("/") + 1) : x = "", y = (b) => { + try { + var c = new XMLHttpRequest(); + c.open("GET", b, false); + c.send(null); + return c.responseText; + } catch (f) { + if (b = C(b)) { + c = []; + for (var d = 0; d < b.length; d++) { + var e = b[d]; + 255 < e && (e &= 255); + c.push(String.fromCharCode(e)); + } + return c.join(""); + } + throw f; + } + }, v && (A = (b) => { + try { + var c = new XMLHttpRequest(); + c.open("GET", b, false); + c.responseType = "arraybuffer"; + c.send(null); + return new Uint8Array(c.response); + } catch (d) { + if (b = C(b)) + return b; + throw d; + } + }), z = (b, c, d) => { + var e = new XMLHttpRequest(); + e.open("GET", b, true); + e.responseType = "arraybuffer"; + e.onload = () => { + if (200 == e.status || 0 == e.status && e.response) + c(e.response); + else { + var f = C(b); + f ? c(f.buffer) : d(); + } + }; + e.onerror = d; + e.send(null); + }; + var aa = a.print || console.log.bind(console), D = a.printErr || console.warn.bind(console); + Object.assign(a, p); + p = null; + a.thisProgram && (t = a.thisProgram); + var E; + a.wasmBinary && (E = a.wasmBinary); + var noExitRuntime = a.noExitRuntime || true; + "object" != typeof WebAssembly && F("no native wasm support detected"); + var G, H = false, I, J, K, L; + function M() { + var b = G.buffer; + a.HEAP8 = I = new Int8Array(b); + a.HEAP16 = new Int16Array(b); + a.HEAP32 = K = new Int32Array(b); + a.HEAPU8 = J = new Uint8Array(b); + a.HEAPU16 = new Uint16Array(b); + a.HEAPU32 = L = new Uint32Array(b); + a.HEAPF32 = new Float32Array(b); + a.HEAPF64 = new Float64Array(b); + } + var ba = [], ca = [], da = []; + function ea() { + var b = a.preRun.shift(); + ba.unshift(b); + } + var N = 0, O = null, P = null; + function F(b) { + if (a.onAbort) + a.onAbort(b); + b = "Aborted(" + b + ")"; + D(b); + H = true; + b = new WebAssembly.RuntimeError(b + ". Build with -sASSERTIONS for more info."); + n(b); + throw b; + } + var Q = "data:application/octet-stream;base64,", R; + R = "data:application/octet-stream;base64,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"; + if (!R.startsWith(Q)) { + var fa = R; + R = a.locateFile ? a.locateFile(fa, x) : x + fa; + } + function ha(b) { + try { + if (b == R && E) + return new Uint8Array(E); + var c = C(b); + if (c) + return c; + if (A) + return A(b); + throw "both async and sync fetching of the wasm failed"; + } catch (d) { + F(d); + } + } + function ia(b) { + if (!E && (u || v)) { + if ("function" == typeof fetch && !b.startsWith("file://")) + return fetch(b, { credentials: "same-origin" }).then(function(c) { + if (!c.ok) + throw "failed to load wasm binary file at '" + b + "'"; + return c.arrayBuffer(); + }).catch(function() { + return ha(b); + }); + if (z) + return new Promise(function(c, d) { + z(b, function(e) { + c(new Uint8Array(e)); + }, d); + }); + } + return Promise.resolve().then(function() { + return ha(b); + }); + } + function ja(b, c, d) { + return ia(b).then(function(e) { + return WebAssembly.instantiate(e, c); + }).then(function(e) { + return e; + }).then(d, function(e) { + D("failed to asynchronously prepare wasm: " + e); + F(e); + }); + } + function ka(b, c) { + var d = R; + return E || "function" != typeof WebAssembly.instantiateStreaming || d.startsWith(Q) || d.startsWith("file://") || w || "function" != typeof fetch ? ja(d, b, c) : fetch(d, { credentials: "same-origin" }).then(function(e) { + return WebAssembly.instantiateStreaming(e, b).then(c, function(f) { + D("wasm streaming compile failed: " + f); + D("falling back to ArrayBuffer instantiation"); + return ja(d, b, c); + }); + }); + } + function S(b) { + for (; 0 < b.length; ) + b.shift()(a); + } + var la = "undefined" != typeof TextDecoder ? new TextDecoder("utf8") : void 0; + function na(b, c, d) { + var e = c + d; + for (d = c; b[d] && !(d >= e); ) + ++d; + if (16 < d - c && b.buffer && la) + return la.decode(b.subarray(c, d)); + for (e = ""; c < d; ) { + var f = b[c++]; + if (f & 128) { + var g = b[c++] & 63; + if (192 == (f & 224)) + e += String.fromCharCode((f & 31) << 6 | g); + else { + var h = b[c++] & 63; + f = 224 == (f & 240) ? (f & 15) << 12 | g << 6 | h : (f & 7) << 18 | g << 12 | h << 6 | b[c++] & 63; + 65536 > f ? e += String.fromCharCode(f) : (f -= 65536, e += String.fromCharCode(55296 | f >> 10, 56320 | f & 1023)); + } + } else + e += String.fromCharCode(f); + } + return e; + } + function T(b, c) { + return b ? na(J, b, c) : ""; + } + var oa = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], pa = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]; + function U(b) { + for (var c = 0, d = 0; d < b.length; ++d) { + var e = b.charCodeAt(d); + 127 >= e ? c++ : 2047 >= e ? c += 2 : 55296 <= e && 57343 >= e ? (c += 4, ++d) : c += 3; + } + return c; + } + function V(b, c, d) { + var e = J; + if (!(0 < d)) + return 0; + var f = c; + d = c + d - 1; + for (var g = 0; g < b.length; ++g) { + var h = b.charCodeAt(g); + if (55296 <= h && 57343 >= h) { + var k = b.charCodeAt(++g); + h = 65536 + ((h & 1023) << 10) | k & 1023; + } + if (127 >= h) { + if (c >= d) + break; + e[c++] = h; + } else { + if (2047 >= h) { + if (c + 1 >= d) + break; + e[c++] = 192 | h >> 6; + } else { + if (65535 >= h) { + if (c + 2 >= d) + break; + e[c++] = 224 | h >> 12; + } else { + if (c + 3 >= d) + break; + e[c++] = 240 | h >> 18; + e[c++] = 128 | h >> 12 & 63; + } + e[c++] = 128 | h >> 6 & 63; + } + e[c++] = 128 | h & 63; + } + } + e[c] = 0; + return c - f; + } + function qa(b) { + var c = U(b) + 1, d = ra(c); + d && V(b, d, c); + return d; + } + var W = {}; + function sa() { + if (!X) { + var b = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: ("object" == typeof navigator && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", _: t || "./this.program" }, c; + for (c in W) + void 0 === W[c] ? delete b[c] : b[c] = W[c]; + var d = []; + for (c in b) + d.push(c + "=" + b[c]); + X = d; + } + return X; + } + var X, ta = [null, [], []]; + function ua(b, c, d, e) { + var f = { string: (l) => { + var q = 0; + if (null !== l && void 0 !== l && 0 !== l) { + q = U(l) + 1; + var ma = Y(q); + V(l, ma, q); + q = ma; + } + return q; + }, array: (l) => { + var q = Y(l.length); + I.set(l, q); + return q; + } }; + b = a["_" + b]; + var g = [], h = 0; + if (e) + for (var k = 0; k < e.length; k++) { + var r = f[d[k]]; + r ? (0 === h && (h = va()), g[k] = r(e[k])) : g[k] = e[k]; + } + d = b.apply(null, g); + return d = function(l) { + 0 !== h && wa(h); + return "string" === c ? T(l) : "boolean" === c ? !!l : l; + }(d); + } + var xa = "function" == typeof atob ? atob : function(b) { + var c = "", d = 0; + b = b.replace(/[^A-Za-z0-9\+\/=]/g, ""); + do { + var e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(b.charAt(d++)); + var f = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(b.charAt(d++)); + var g = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(b.charAt(d++)); + var h = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(b.charAt(d++)); + e = e << 2 | f >> 4; + f = (f & 15) << 4 | g >> 2; + var k = (g & 3) << 6 | h; + c += String.fromCharCode(e); + 64 !== g && (c += String.fromCharCode(f)); + 64 !== h && (c += String.fromCharCode(k)); + } while (d < b.length); + return c; + }; + function C(b) { + if (b.startsWith(Q)) { + b = b.slice(Q.length); + if ("boolean" == typeof w && w) { + var c = Buffer.from(b, "base64"); + c = new Uint8Array(c.buffer, c.byteOffset, c.byteLength); + } else + try { + var d = xa(b), e = new Uint8Array(d.length); + for (b = 0; b < d.length; ++b) + e[b] = d.charCodeAt(b); + c = e; + } catch (f) { + throw Error("Converting base64 string to bytes failed."); + } + return c; + } + } + var ya = { + a: function(b, c, d, e) { + F("Assertion failed: " + T(b) + ", at: " + [c ? T(c) : "unknown filename", d, e ? T(e) : "unknown function"]); + }, + l: function(b, c) { + b = new Date(1e3 * (L[b >> 2] + 4294967296 * K[b + 4 >> 2])); + K[c >> 2] = b.getSeconds(); + K[c + 4 >> 2] = b.getMinutes(); + K[c + 8 >> 2] = b.getHours(); + K[c + 12 >> 2] = b.getDate(); + K[c + 16 >> 2] = b.getMonth(); + K[c + 20 >> 2] = b.getFullYear() - 1900; + K[c + 24 >> 2] = b.getDay(); + var d = b.getFullYear(); + K[c + 28 >> 2] = (0 !== d % 4 || 0 === d % 100 && 0 !== d % 400 ? pa : oa)[b.getMonth()] + b.getDate() - 1 | 0; + K[c + 36 >> 2] = -(60 * b.getTimezoneOffset()); + d = new Date(b.getFullYear(), 6, 1).getTimezoneOffset(); + var e = new Date(b.getFullYear(), 0, 1).getTimezoneOffset(); + K[c + 32 >> 2] = (d != e && b.getTimezoneOffset() == Math.min(e, d)) | 0; + }, + k: function(b, c, d) { + function e(r) { + return (r = r.toTimeString().match(/\(([A-Za-z ]+)\)$/)) ? r[1] : "GMT"; + } + var f = (/* @__PURE__ */ new Date()).getFullYear(), g = new Date(f, 0, 1), h = new Date(f, 6, 1); + f = g.getTimezoneOffset(); + var k = h.getTimezoneOffset(); + L[b >> 2] = 60 * Math.max(f, k); + K[c >> 2] = Number(f != k); + b = e(g); + c = e(h); + b = qa(b); + c = qa(c); + k < f ? (L[d >> 2] = b, L[d + 4 >> 2] = c) : (L[d >> 2] = c, L[d + 4 >> 2] = b); + }, + b: function() { + F(""); + }, + m: function() { + return Date.now(); + }, + j: function(b) { + var c = J.length; + b >>>= 0; + if (2147483648 < b) + return false; + for (var d = 1; 4 >= d; d *= 2) { + var e = c * (1 + 0.2 / d); + e = Math.min(e, b + 100663296); + var f = Math, g = f.min; + e = Math.max(b, e); + e += (65536 - e % 65536) % 65536; + a: { + var h = G.buffer; + try { + G.grow(g.call(f, 2147483648, e) - h.byteLength + 65535 >>> 16); + M(); + var k = 1; + break a; + } catch (r) { + } + k = void 0; + } + if (k) + return true; + } + return false; + }, + e: function(b, c) { + var d = 0; + sa().forEach(function(e, f) { + var g = c + d; + f = L[b + 4 * f >> 2] = g; + for (g = 0; g < e.length; ++g) + I[f++ >> 0] = e.charCodeAt(g); + I[f >> 0] = 0; + d += e.length + 1; + }); + return 0; + }, + f: function(b, c) { + var d = sa(); + L[b >> 2] = d.length; + var e = 0; + d.forEach(function(f) { + e += f.length + 1; + }); + L[c >> 2] = e; + return 0; + }, + d: function() { + return 52; + }, + i: function() { + return 70; + }, + c: function(b, c, d, e) { + for (var f = 0, g = 0; g < d; g++) { + var h = L[c >> 2], k = L[c + 4 >> 2]; + c += 8; + for (var r = 0; r < k; r++) { + var l = J[h + r], q = ta[b]; + 0 === l || 10 === l ? ((1 === b ? aa : D)(na(q, 0)), q.length = 0) : q.push(l); + } + f += k; + } + L[e >> 2] = f; + return 0; + }, + o: function(b, c, d, e, f) { + return a.callbacks.callFunction(void 0, b, c, d, e, f); + }, + n: function(b) { + return a.callbacks.shouldInterrupt(void 0, b); + }, + h: function(b, c, d) { + d = T(d); + return a.callbacks.loadModuleSource(void 0, b, c, d); + }, + g: function(b, c, d, e) { + d = T(d); + e = T(e); + return a.callbacks.normalizeModule(void 0, b, c, d, e); + } + }; + (function() { + function b(d) { + d = d.exports; + a.asm = d; + G = a.asm.p; + M(); + ca.unshift(a.asm.q); + N--; + a.monitorRunDependencies && a.monitorRunDependencies(N); + if (0 == N && (null !== O && (clearInterval(O), O = null), P)) { + var e = P; + P = null; + e(); + } + return d; + } + var c = { a: ya }; + N++; + a.monitorRunDependencies && a.monitorRunDependencies(N); + if (a.instantiateWasm) + try { + return a.instantiateWasm(c, b); + } catch (d) { + D("Module.instantiateWasm callback failed with error: " + d), n(d); + } + ka(c, function(d) { + b(d.instance); + }).catch(n); + return {}; + })(); + var ra = a._malloc = function() { + return (ra = a._malloc = a.asm.r).apply(null, arguments); + }; + a._QTS_Throw = function() { + return (a._QTS_Throw = a.asm.s).apply(null, arguments); + }; + a._QTS_NewError = function() { + return (a._QTS_NewError = a.asm.t).apply(null, arguments); + }; + a._QTS_RuntimeSetMemoryLimit = function() { + return (a._QTS_RuntimeSetMemoryLimit = a.asm.u).apply(null, arguments); + }; + a._QTS_RuntimeComputeMemoryUsage = function() { + return (a._QTS_RuntimeComputeMemoryUsage = a.asm.v).apply(null, arguments); + }; + a._QTS_RuntimeDumpMemoryUsage = function() { + return (a._QTS_RuntimeDumpMemoryUsage = a.asm.w).apply(null, arguments); + }; + a._QTS_RecoverableLeakCheck = function() { + return (a._QTS_RecoverableLeakCheck = a.asm.x).apply(null, arguments); + }; + a._QTS_BuildIsSanitizeLeak = function() { + return (a._QTS_BuildIsSanitizeLeak = a.asm.y).apply(null, arguments); + }; + a._QTS_RuntimeSetMaxStackSize = function() { + return (a._QTS_RuntimeSetMaxStackSize = a.asm.z).apply(null, arguments); + }; + a._QTS_GetUndefined = function() { + return (a._QTS_GetUndefined = a.asm.A).apply(null, arguments); + }; + a._QTS_GetNull = function() { + return (a._QTS_GetNull = a.asm.B).apply(null, arguments); + }; + a._QTS_GetFalse = function() { + return (a._QTS_GetFalse = a.asm.C).apply(null, arguments); + }; + a._QTS_GetTrue = function() { + return (a._QTS_GetTrue = a.asm.D).apply(null, arguments); + }; + a._QTS_NewRuntime = function() { + return (a._QTS_NewRuntime = a.asm.E).apply(null, arguments); + }; + a._QTS_FreeRuntime = function() { + return (a._QTS_FreeRuntime = a.asm.F).apply(null, arguments); + }; + a._QTS_NewContext = function() { + return (a._QTS_NewContext = a.asm.G).apply(null, arguments); + }; + a._QTS_FreeContext = function() { + return (a._QTS_FreeContext = a.asm.H).apply(null, arguments); + }; + a._QTS_FreeValuePointer = function() { + return (a._QTS_FreeValuePointer = a.asm.I).apply(null, arguments); + }; + a._free = function() { + return (a._free = a.asm.J).apply(null, arguments); + }; + a._QTS_FreeValuePointerRuntime = function() { + return (a._QTS_FreeValuePointerRuntime = a.asm.K).apply(null, arguments); + }; + a._QTS_FreeVoidPointer = function() { + return (a._QTS_FreeVoidPointer = a.asm.L).apply(null, arguments); + }; + a._QTS_FreeCString = function() { + return (a._QTS_FreeCString = a.asm.M).apply(null, arguments); + }; + a._QTS_DupValuePointer = function() { + return (a._QTS_DupValuePointer = a.asm.N).apply(null, arguments); + }; + a._QTS_NewObject = function() { + return (a._QTS_NewObject = a.asm.O).apply(null, arguments); + }; + a._QTS_NewObjectProto = function() { + return (a._QTS_NewObjectProto = a.asm.P).apply(null, arguments); + }; + a._QTS_NewArray = function() { + return (a._QTS_NewArray = a.asm.Q).apply(null, arguments); + }; + a._QTS_NewFloat64 = function() { + return (a._QTS_NewFloat64 = a.asm.R).apply(null, arguments); + }; + a._QTS_GetFloat64 = function() { + return (a._QTS_GetFloat64 = a.asm.S).apply(null, arguments); + }; + a._QTS_NewString = function() { + return (a._QTS_NewString = a.asm.T).apply(null, arguments); + }; + a._QTS_GetString = function() { + return (a._QTS_GetString = a.asm.U).apply(null, arguments); + }; + a._QTS_NewSymbol = function() { + return (a._QTS_NewSymbol = a.asm.V).apply(null, arguments); + }; + a._QTS_GetSymbolDescriptionOrKey = function() { + return (a._QTS_GetSymbolDescriptionOrKey = a.asm.W).apply(null, arguments); + }; + a._QTS_IsGlobalSymbol = function() { + return (a._QTS_IsGlobalSymbol = a.asm.X).apply(null, arguments); + }; + a._QTS_IsJobPending = function() { + return (a._QTS_IsJobPending = a.asm.Y).apply(null, arguments); + }; + a._QTS_ExecutePendingJob = function() { + return (a._QTS_ExecutePendingJob = a.asm.Z).apply(null, arguments); + }; + a._QTS_GetProp = function() { + return (a._QTS_GetProp = a.asm._).apply(null, arguments); + }; + a._QTS_SetProp = function() { + return (a._QTS_SetProp = a.asm.$).apply(null, arguments); + }; + a._QTS_DefineProp = function() { + return (a._QTS_DefineProp = a.asm.aa).apply(null, arguments); + }; + a._QTS_Call = function() { + return (a._QTS_Call = a.asm.ba).apply(null, arguments); + }; + a._QTS_ResolveException = function() { + return (a._QTS_ResolveException = a.asm.ca).apply(null, arguments); + }; + a._QTS_Dump = function() { + return (a._QTS_Dump = a.asm.da).apply(null, arguments); + }; + a._QTS_Eval = function() { + return (a._QTS_Eval = a.asm.ea).apply(null, arguments); + }; + a._QTS_Typeof = function() { + return (a._QTS_Typeof = a.asm.fa).apply(null, arguments); + }; + a._QTS_GetGlobalObject = function() { + return (a._QTS_GetGlobalObject = a.asm.ga).apply(null, arguments); + }; + a._QTS_NewPromiseCapability = function() { + return (a._QTS_NewPromiseCapability = a.asm.ha).apply(null, arguments); + }; + a._QTS_TestStringArg = function() { + return (a._QTS_TestStringArg = a.asm.ia).apply(null, arguments); + }; + a._QTS_BuildIsDebug = function() { + return (a._QTS_BuildIsDebug = a.asm.ja).apply(null, arguments); + }; + a._QTS_BuildIsAsyncify = function() { + return (a._QTS_BuildIsAsyncify = a.asm.ka).apply(null, arguments); + }; + a._QTS_NewFunction = function() { + return (a._QTS_NewFunction = a.asm.la).apply(null, arguments); + }; + a._QTS_ArgvGetJSValueConstPointer = function() { + return (a._QTS_ArgvGetJSValueConstPointer = a.asm.ma).apply(null, arguments); + }; + a._QTS_RuntimeEnableInterruptHandler = function() { + return (a._QTS_RuntimeEnableInterruptHandler = a.asm.na).apply(null, arguments); + }; + a._QTS_RuntimeDisableInterruptHandler = function() { + return (a._QTS_RuntimeDisableInterruptHandler = a.asm.oa).apply(null, arguments); + }; + a._QTS_RuntimeEnableModuleLoader = function() { + return (a._QTS_RuntimeEnableModuleLoader = a.asm.pa).apply(null, arguments); + }; + a._QTS_RuntimeDisableModuleLoader = function() { + return (a._QTS_RuntimeDisableModuleLoader = a.asm.qa).apply(null, arguments); + }; + function va() { + return (va = a.asm.sa).apply(null, arguments); + } + function wa() { + return (wa = a.asm.ta).apply(null, arguments); + } + function Y() { + return (Y = a.asm.ua).apply(null, arguments); + } + a.___start_em_js = 74916; + a.___stop_em_js = 75818; + a.cwrap = function(b, c, d, e) { + var f = !d || d.every((g) => "number" === g || "boolean" === g); + return "string" !== c && f && !e ? a["_" + b] : function() { + return ua(b, c, d, arguments); + }; + }; + a.UTF8ToString = T; + a.stringToUTF8 = function(b, c, d) { + return V(b, c, d); + }; + a.lengthBytesUTF8 = U; + var Z; + P = function za() { + Z || Aa(); + Z || (P = za); + }; + function Aa() { + function b() { + if (!Z && (Z = true, a.calledRun = true, !H)) { + S(ca); + m(a); + if (a.onRuntimeInitialized) + a.onRuntimeInitialized(); + if (a.postRun) + for ("function" == typeof a.postRun && (a.postRun = [a.postRun]); a.postRun.length; ) { + var c = a.postRun.shift(); + da.unshift(c); + } + S(da); + } + } + if (!(0 < N)) { + if (a.preRun) + for ("function" == typeof a.preRun && (a.preRun = [a.preRun]); a.preRun.length; ) + ea(); + S(ba); + 0 < N || (a.setStatus ? (a.setStatus("Running..."), setTimeout(function() { + setTimeout(function() { + a.setStatus(""); + }, 1); + b(); + }, 1)) : b()); + } + } + if (a.preInit) + for ("function" == typeof a.preInit && (a.preInit = [a.preInit]); 0 < a.preInit.length; ) + a.preInit.pop()(); + Aa(); + return QuickJSRaw2.ready; + }; + })(); + if (typeof exports === "object" && typeof module === "object") + module.exports = QuickJSRaw; + else if (typeof define === "function" && define["amd"]) + define([], function() { + return QuickJSRaw; + }); + else if (typeof exports === "object") + exports["QuickJSRaw"] = QuickJSRaw; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/variants.js +var require_variants = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/variants.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.RELEASE_ASYNC = exports.DEBUG_ASYNC = exports.RELEASE_SYNC = exports.DEBUG_SYNC = exports.memoizePromiseFactory = exports.newQuickJSAsyncWASMModule = exports.newQuickJSWASMModule = void 0; + var esmHelpers_1 = require_esmHelpers(); + async function newQuickJSWASMModule(variant = exports.RELEASE_SYNC) { + const [wasmModuleLoader, QuickJSFFI, { QuickJSWASMModule }] = await Promise.all([ + variant.importModuleLoader(), + variant.importFFI(), + Promise.resolve().then(() => __importStar2(require_module())).then(esmHelpers_1.unwrapTypescript) + ]); + const wasmModule = await wasmModuleLoader(); + wasmModule.type = "sync"; + const ffi = new QuickJSFFI(wasmModule); + return new QuickJSWASMModule(wasmModule, ffi); + } + exports.newQuickJSWASMModule = newQuickJSWASMModule; + async function newQuickJSAsyncWASMModule(variant = exports.RELEASE_ASYNC) { + const [wasmModuleLoader, QuickJSAsyncFFI, { QuickJSAsyncWASMModule }] = await Promise.all([ + variant.importModuleLoader(), + variant.importFFI(), + Promise.resolve().then(() => __importStar2(require_module_asyncify())).then(esmHelpers_1.unwrapTypescript) + ]); + const wasmModule = await wasmModuleLoader(); + wasmModule.type = "async"; + const ffi = new QuickJSAsyncFFI(wasmModule); + return new QuickJSAsyncWASMModule(wasmModule, ffi); + } + exports.newQuickJSAsyncWASMModule = newQuickJSAsyncWASMModule; + function memoizePromiseFactory(fn) { + let promise; + return () => { + return promise ?? (promise = fn()); + }; + } + exports.memoizePromiseFactory = memoizePromiseFactory; + exports.DEBUG_SYNC = { + type: "sync", + async importFFI() { + throw new Error("not implemented"); + }, + async importModuleLoader() { + throw new Error("not implemented"); + } + }; + exports.RELEASE_SYNC = { + type: "sync", + async importFFI() { + const mod = await Promise.resolve().then(() => __importStar2(require_ffi_WASM_RELEASE_SYNC())); + return (0, esmHelpers_1.unwrapTypescript)(mod).QuickJSFFI; + }, + async importModuleLoader() { + const mod = await Promise.resolve().then(() => __importStar2(require_emscripten_module_WASM_RELEASE_SYNC())); + return (0, esmHelpers_1.unwrapJavascript)(mod); + } + }; + exports.DEBUG_ASYNC = { + type: "async", + async importFFI() { + throw new Error("not implemented"); + }, + async importModuleLoader() { + throw new Error("not implemented"); + } + }; + exports.RELEASE_ASYNC = { + type: "async", + async importFFI() { + throw new Error("not implemented"); + }, + async importModuleLoader() { + throw new Error("not implemented"); + } + }; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/vm-interface.js +var require_vm_interface = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/vm-interface.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isFail = exports.isSuccess = void 0; + function isSuccess(successOrFail) { + return "error" in successOrFail === false; + } + exports.isSuccess = isSuccess; + function isFail(successOrFail) { + return "error" in successOrFail === true; + } + exports.isFail = isFail; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/module-test.js +var require_module_test = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/module-test.js"(exports) { + "use strict"; + init_cjs_shim(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.TestQuickJSWASMModule = void 0; + var errors_1 = require_errors(); + var lifetime_1 = require_lifetime(); + var TestQuickJSWASMModule = class { + constructor(parent) { + this.parent = parent; + this.contexts = /* @__PURE__ */ new Set(); + this.runtimes = /* @__PURE__ */ new Set(); + } + newRuntime(options) { + const runtime = this.parent.newRuntime({ + ...options, + ownedLifetimes: [ + new lifetime_1.Lifetime(void 0, void 0, () => this.runtimes.delete(runtime)), + ...options?.ownedLifetimes ?? [] + ] + }); + this.runtimes.add(runtime); + return runtime; + } + newContext(options) { + const context = this.parent.newContext({ + ...options, + ownedLifetimes: [ + new lifetime_1.Lifetime(void 0, void 0, () => this.contexts.delete(context)), + ...options?.ownedLifetimes ?? [] + ] + }); + this.contexts.add(context); + return context; + } + evalCode(code, options) { + return this.parent.evalCode(code, options); + } + disposeAll() { + const allDisposables = [...this.contexts, ...this.runtimes]; + this.runtimes.clear(); + this.contexts.clear(); + allDisposables.forEach((d) => { + if (d.alive) { + d.dispose(); + } + }); + } + assertNoMemoryAllocated() { + const leaksDetected = this.getFFI().QTS_RecoverableLeakCheck(); + if (leaksDetected) { + throw new errors_1.QuickJSMemoryLeakDetected("Leak sanitizer detected un-freed memory"); + } + if (this.contexts.size > 0) { + throw new errors_1.QuickJSMemoryLeakDetected(`${this.contexts.size} contexts leaked`); + } + if (this.runtimes.size > 0) { + throw new errors_1.QuickJSMemoryLeakDetected(`${this.runtimes.size} runtimes leaked`); + } + } + /** @private */ + getFFI() { + return this.parent.getFFI(); + } + }; + exports.TestQuickJSWASMModule = TestQuickJSWASMModule; + } +}); + +// ../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/index.js +var require_dist9 = __commonJS({ + "../testeranto/node_modules/@tootallnate/quickjs-emscripten/dist/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __exportStar2 = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) + if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) + __createBinding2(exports2, m, p); + }; + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.shouldInterruptAfterDeadline = exports.newAsyncContext = exports.newAsyncRuntime = exports.getQuickJSSync = exports.getQuickJS = exports.errors = exports.RELEASE_SYNC = exports.RELEASE_ASYNC = exports.DEBUG_SYNC = exports.DEBUG_ASYNC = exports.newQuickJSAsyncWASMModule = exports.newQuickJSWASMModule = void 0; + var variants_1 = require_variants(); + Object.defineProperty(exports, "newQuickJSWASMModule", { enumerable: true, get: function() { + return variants_1.newQuickJSWASMModule; + } }); + Object.defineProperty(exports, "newQuickJSAsyncWASMModule", { enumerable: true, get: function() { + return variants_1.newQuickJSAsyncWASMModule; + } }); + Object.defineProperty(exports, "DEBUG_ASYNC", { enumerable: true, get: function() { + return variants_1.DEBUG_ASYNC; + } }); + Object.defineProperty(exports, "DEBUG_SYNC", { enumerable: true, get: function() { + return variants_1.DEBUG_SYNC; + } }); + Object.defineProperty(exports, "RELEASE_ASYNC", { enumerable: true, get: function() { + return variants_1.RELEASE_ASYNC; + } }); + Object.defineProperty(exports, "RELEASE_SYNC", { enumerable: true, get: function() { + return variants_1.RELEASE_SYNC; + } }); + __exportStar2(require_vm_interface(), exports); + __exportStar2(require_lifetime(), exports); + exports.errors = __importStar2(require_errors()); + __exportStar2(require_deferred_promise(), exports); + __exportStar2(require_module_test(), exports); + var singleton = void 0; + var singletonPromise = void 0; + async function getQuickJS() { + singletonPromise ?? (singletonPromise = (0, variants_1.newQuickJSWASMModule)().then((instance) => { + singleton = instance; + return instance; + })); + return await singletonPromise; + } + exports.getQuickJS = getQuickJS; + function getQuickJSSync() { + if (!singleton) { + throw new Error("QuickJS not initialized. Await getQuickJS() at least once."); + } + return singleton; + } + exports.getQuickJSSync = getQuickJSSync; + async function newAsyncRuntime(options) { + const module2 = await (0, variants_1.newQuickJSAsyncWASMModule)(); + return module2.newRuntime(options); + } + exports.newAsyncRuntime = newAsyncRuntime; + async function newAsyncContext(options) { + const module2 = await (0, variants_1.newQuickJSAsyncWASMModule)(); + return module2.newContext(options); + } + exports.newAsyncContext = newAsyncContext; + function shouldInterruptAfterDeadline(deadline) { + const deadlineAsNumber = typeof deadline === "number" ? deadline : deadline.getTime(); + return function() { + return Date.now() > deadlineAsNumber; + }; + } + exports.shouldInterruptAfterDeadline = shouldInterruptAfterDeadline; + } +}); + +// ../testeranto/node_modules/pac-proxy-agent/dist/index.js +var require_dist10 = __commonJS({ + "../testeranto/node_modules/pac-proxy-agent/dist/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.PacProxyAgent = void 0; + var net = __importStar2(__require("net")); + var tls = __importStar2(__require("tls")); + var crypto = __importStar2(__require("crypto")); + var events_1 = __require("events"); + var debug_1 = __importDefault2(require_src()); + var url_1 = __require("url"); + var agent_base_1 = require_dist(); + var http_proxy_agent_1 = require_dist2(); + var https_proxy_agent_1 = require_dist3(); + var socks_proxy_agent_1 = require_dist4(); + var get_uri_1 = require_dist6(); + var pac_resolver_1 = require_dist8(); + var quickjs_emscripten_1 = require_dist9(); + var debug5 = (0, debug_1.default)("pac-proxy-agent"); + var PacProxyAgent = class extends agent_base_1.Agent { + constructor(uri, opts) { + super(opts); + this.clearResolverPromise = () => { + this.resolverPromise = void 0; + }; + const uriStr = typeof uri === "string" ? uri : uri.href; + this.uri = new url_1.URL(uriStr.replace(/^pac\+/i, "")); + debug5("Creating PacProxyAgent with URI %o", this.uri.href); + this.opts = { ...opts }; + this.cache = void 0; + this.resolver = void 0; + this.resolverHash = ""; + this.resolverPromise = void 0; + if (!this.opts.filename) { + this.opts.filename = this.uri.href; + } + } + /** + * Loads the PAC proxy file from the source if necessary, and returns + * a generated `FindProxyForURL()` resolver function to use. + * + * @api private + */ + getResolver() { + if (!this.resolverPromise) { + this.resolverPromise = this.loadResolver(); + this.resolverPromise.then(this.clearResolverPromise, this.clearResolverPromise); + } + return this.resolverPromise; + } + async loadResolver() { + try { + const [qjs, code] = await Promise.all([ + (0, quickjs_emscripten_1.getQuickJS)(), + this.loadPacFile() + ]); + const hash = crypto.createHash("sha1").update(code).digest("hex"); + if (this.resolver && this.resolverHash === hash) { + debug5("Same sha1 hash for code - contents have not changed, reusing previous proxy resolver"); + return this.resolver; + } + debug5("Creating new proxy resolver instance"); + this.resolver = (0, pac_resolver_1.createPacResolver)(qjs, code, this.opts); + this.resolverHash = hash; + return this.resolver; + } catch (err) { + if (this.resolver && err.code === "ENOTMODIFIED") { + debug5("Got ENOTMODIFIED response, reusing previous proxy resolver"); + return this.resolver; + } + throw err; + } + } + /** + * Loads the contents of the PAC proxy file. + * + * @api private + */ + async loadPacFile() { + debug5("Loading PAC file: %o", this.uri); + const rs = await (0, get_uri_1.getUri)(this.uri, { ...this.opts, cache: this.cache }); + debug5("Got `Readable` instance for URI"); + this.cache = rs; + const buf = await (0, agent_base_1.toBuffer)(rs); + debug5("Read %o byte PAC file from URI", buf.length); + return buf.toString("utf8"); + } + /** + * Called when the node-core HTTP client library is creating a new HTTP request. + */ + async connect(req, opts) { + const { secureEndpoint } = opts; + const resolver = await this.getResolver(); + const defaultPort = secureEndpoint ? 443 : 80; + let path10 = req.path; + let search = null; + const firstQuestion = path10.indexOf("?"); + if (firstQuestion !== -1) { + search = path10.substring(firstQuestion); + path10 = path10.substring(0, firstQuestion); + } + const urlOpts = { + ...opts, + protocol: secureEndpoint ? "https:" : "http:", + pathname: path10, + search, + // need to use `hostname` instead of `host` otherwise `port` is ignored + hostname: opts.host, + host: null, + href: null, + // set `port` to null when it is the protocol default port (80 / 443) + port: defaultPort === opts.port ? null : opts.port + }; + const url = (0, url_1.format)(urlOpts); + debug5("url: %o", url); + let result = await resolver(url); + if (!result) { + result = "DIRECT"; + } + const proxies = String(result).trim().split(/\s*;\s*/g).filter(Boolean); + if (this.opts.fallbackToDirect && !proxies.includes("DIRECT")) { + proxies.push("DIRECT"); + } + for (const proxy of proxies) { + let agent = null; + let socket = null; + const [type, target] = proxy.split(/\s+/); + debug5("Attempting to use proxy: %o", proxy); + if (type === "DIRECT") { + if (secureEndpoint) { + const servername = opts.servername || opts.host; + socket = tls.connect({ + ...opts, + servername + }); + } else { + socket = net.connect(opts); + } + } else if (type === "SOCKS" || type === "SOCKS5") { + agent = new socks_proxy_agent_1.SocksProxyAgent(`socks://${target}`, this.opts); + } else if (type === "SOCKS4") { + agent = new socks_proxy_agent_1.SocksProxyAgent(`socks4a://${target}`, this.opts); + } else if (type === "PROXY" || type === "HTTP" || type === "HTTPS") { + const proxyURL = `${type === "HTTPS" ? "https" : "http"}://${target}`; + if (secureEndpoint) { + agent = new https_proxy_agent_1.HttpsProxyAgent(proxyURL, this.opts); + } else { + agent = new http_proxy_agent_1.HttpProxyAgent(proxyURL, this.opts); + } + } + try { + if (socket) { + await (0, events_1.once)(socket, "connect"); + req.emit("proxy", { proxy, socket }); + return socket; + } + if (agent) { + const s = await agent.connect(req, opts); + if (!(s instanceof net.Socket)) { + throw new Error("Expected a `net.Socket` to be returned from agent"); + } + req.emit("proxy", { proxy, socket: s }); + return s; + } + throw new Error(`Could not determine proxy type for: ${proxy}`); + } catch (err) { + debug5("Got error for proxy %o: %o", proxy, err); + req.emit("proxy", { proxy, error: err }); + } + } + throw new Error(`Failed to establish a socket connection to proxies: ${JSON.stringify(proxies)}`); + } + }; + PacProxyAgent.protocols = [ + "pac+data", + "pac+file", + "pac+ftp", + "pac+http", + "pac+https" + ]; + exports.PacProxyAgent = PacProxyAgent; + } +}); + +// ../testeranto/node_modules/proxy-agent/dist/index.js +var require_dist11 = __commonJS({ + "../testeranto/node_modules/proxy-agent/dist/index.js"(exports) { + "use strict"; + init_cjs_shim(); + var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) + k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports && exports.__importStar || function(mod) { + if (mod && mod.__esModule) + return mod; + var result = {}; + if (mod != null) { + for (var k in mod) + if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) + __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + var __importDefault2 = exports && exports.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProxyAgent = exports.proxies = void 0; + var http2 = __importStar2(__require("http")); + var https2 = __importStar2(__require("https")); + var url_1 = __require("url"); + var lru_cache_1 = __importDefault2(require_lru_cache()); + var agent_base_1 = require_dist(); + var debug_1 = __importDefault2(require_src()); + var proxy_from_env_1 = require_proxy_from_env(); + var pac_proxy_agent_1 = require_dist10(); + var http_proxy_agent_1 = require_dist2(); + var https_proxy_agent_1 = require_dist3(); + var socks_proxy_agent_1 = require_dist4(); + var debug5 = (0, debug_1.default)("proxy-agent"); + var PROTOCOLS = [ + ...http_proxy_agent_1.HttpProxyAgent.protocols, + ...socks_proxy_agent_1.SocksProxyAgent.protocols, + ...pac_proxy_agent_1.PacProxyAgent.protocols + ]; + exports.proxies = { + http: [http_proxy_agent_1.HttpProxyAgent, https_proxy_agent_1.HttpsProxyAgent], + https: [http_proxy_agent_1.HttpProxyAgent, https_proxy_agent_1.HttpsProxyAgent], + socks: [socks_proxy_agent_1.SocksProxyAgent, socks_proxy_agent_1.SocksProxyAgent], + socks4: [socks_proxy_agent_1.SocksProxyAgent, socks_proxy_agent_1.SocksProxyAgent], + socks4a: [socks_proxy_agent_1.SocksProxyAgent, socks_proxy_agent_1.SocksProxyAgent], + socks5: [socks_proxy_agent_1.SocksProxyAgent, socks_proxy_agent_1.SocksProxyAgent], + socks5h: [socks_proxy_agent_1.SocksProxyAgent, socks_proxy_agent_1.SocksProxyAgent], + "pac+data": [pac_proxy_agent_1.PacProxyAgent, pac_proxy_agent_1.PacProxyAgent], + "pac+file": [pac_proxy_agent_1.PacProxyAgent, pac_proxy_agent_1.PacProxyAgent], + "pac+ftp": [pac_proxy_agent_1.PacProxyAgent, pac_proxy_agent_1.PacProxyAgent], + "pac+http": [pac_proxy_agent_1.PacProxyAgent, pac_proxy_agent_1.PacProxyAgent], + "pac+https": [pac_proxy_agent_1.PacProxyAgent, pac_proxy_agent_1.PacProxyAgent] + }; + function isValidProtocol(v) { + return PROTOCOLS.includes(v); + } + var ProxyAgent2 = class extends agent_base_1.Agent { + constructor(opts) { + super(opts); + this.cache = new lru_cache_1.default({ max: 20 }); + debug5("Creating new ProxyAgent instance: %o", opts); + this.connectOpts = opts; + this.httpAgent = opts?.httpAgent || new http2.Agent(opts); + this.httpsAgent = opts?.httpsAgent || new https2.Agent(opts); + this.getProxyForUrl = opts?.getProxyForUrl || proxy_from_env_1.getProxyForUrl; + } + async connect(req, opts) { + const { secureEndpoint } = opts; + const isWebSocket = req.getHeader("upgrade") === "websocket"; + const protocol = secureEndpoint ? isWebSocket ? "wss:" : "https:" : isWebSocket ? "ws:" : "http:"; + const host = req.getHeader("host"); + const url = new url_1.URL(req.path, `${protocol}//${host}`).href; + const proxy = await this.getProxyForUrl(url); + if (!proxy) { + debug5("Proxy not enabled for URL: %o", url); + return secureEndpoint ? this.httpsAgent : this.httpAgent; + } + debug5("Request URL: %o", url); + debug5("Proxy URL: %o", proxy); + const cacheKey = `${protocol}+${proxy}`; + let agent = this.cache.get(cacheKey); + if (!agent) { + const proxyUrl = new url_1.URL(proxy); + const proxyProto = proxyUrl.protocol.replace(":", ""); + if (!isValidProtocol(proxyProto)) { + throw new Error(`Unsupported protocol for proxy URL: ${proxy}`); + } + const ctor = exports.proxies[proxyProto][secureEndpoint || isWebSocket ? 1 : 0]; + agent = new ctor(proxy, this.connectOpts); + this.cache.set(cacheKey, agent); + } else { + debug5("Cache hit for proxy URL: %o", proxy); + } + return agent; + } + destroy() { + for (const agent of this.cache.values()) { + agent.destroy(); + } + super.destroy(); + } + }; + exports.ProxyAgent = ProxyAgent2; + } +}); + +// ../testeranto/node_modules/wrappy/wrappy.js +var require_wrappy = __commonJS({ + "../testeranto/node_modules/wrappy/wrappy.js"(exports, module) { + init_cjs_shim(); + module.exports = wrappy; + function wrappy(fn, cb) { + if (fn && cb) + return wrappy(fn)(cb); + if (typeof fn !== "function") + throw new TypeError("need wrapper function"); + Object.keys(fn).forEach(function(k) { + wrapper[k] = fn[k]; + }); + return wrapper; + function wrapper() { + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + var ret = fn.apply(this, args); + var cb2 = args[args.length - 1]; + if (typeof ret === "function" && ret !== cb2) { + Object.keys(cb2).forEach(function(k) { + ret[k] = cb2[k]; + }); + } + return ret; + } + } + } +}); + +// ../testeranto/node_modules/once/once.js +var require_once = __commonJS({ + "../testeranto/node_modules/once/once.js"(exports, module) { + init_cjs_shim(); + var wrappy = require_wrappy(); + module.exports = wrappy(once); + module.exports.strict = wrappy(onceStrict); + once.proto = once(function() { + Object.defineProperty(Function.prototype, "once", { + value: function() { + return once(this); + }, + configurable: true + }); + Object.defineProperty(Function.prototype, "onceStrict", { + value: function() { + return onceStrict(this); + }, + configurable: true + }); + }); + function once(fn) { + var f = function() { + if (f.called) + return f.value; + f.called = true; + return f.value = fn.apply(this, arguments); + }; + f.called = false; + return f; + } + function onceStrict(fn) { + var f = function() { + if (f.called) + throw new Error(f.onceError); + f.called = true; + return f.value = fn.apply(this, arguments); + }; + var name = fn.name || "Function wrapped with `once`"; + f.onceError = name + " shouldn't be called more than once"; + f.called = false; + return f; + } + } +}); + +// ../testeranto/node_modules/end-of-stream/index.js +var require_end_of_stream = __commonJS({ + "../testeranto/node_modules/end-of-stream/index.js"(exports, module) { + init_cjs_shim(); + var once = require_once(); + var noop = function() { + }; + var isRequest = function(stream) { + return stream.setHeader && typeof stream.abort === "function"; + }; + var isChildProcess = function(stream) { + return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3; + }; + var eos = function(stream, opts, callback) { + if (typeof opts === "function") + return eos(stream, null, opts); + if (!opts) + opts = {}; + callback = once(callback || noop); + var ws = stream._writableState; + var rs = stream._readableState; + var readable = opts.readable || opts.readable !== false && stream.readable; + var writable = opts.writable || opts.writable !== false && stream.writable; + var cancelled = false; + var onlegacyfinish = function() { + if (!stream.writable) + onfinish(); + }; + var onfinish = function() { + writable = false; + if (!readable) + callback.call(stream); + }; + var onend = function() { + readable = false; + if (!writable) + callback.call(stream); + }; + var onexit = function(exitCode) { + callback.call(stream, exitCode ? new Error("exited with error code: " + exitCode) : null); + }; + var onerror = function(err) { + callback.call(stream, err); + }; + var onclose = function() { + process.nextTick(onclosenexttick); + }; + var onclosenexttick = function() { + if (cancelled) + return; + if (readable && !(rs && (rs.ended && !rs.destroyed))) + return callback.call(stream, new Error("premature close")); + if (writable && !(ws && (ws.ended && !ws.destroyed))) + return callback.call(stream, new Error("premature close")); + }; + var onrequest = function() { + stream.req.on("finish", onfinish); + }; + if (isRequest(stream)) { + stream.on("complete", onfinish); + stream.on("abort", onclose); + if (stream.req) + onrequest(); + else + stream.on("request", onrequest); + } else if (writable && !ws) { + stream.on("end", onlegacyfinish); + stream.on("close", onlegacyfinish); + } + if (isChildProcess(stream)) + stream.on("exit", onexit); + stream.on("end", onend); + stream.on("finish", onfinish); + if (opts.error !== false) + stream.on("error", onerror); + stream.on("close", onclose); + return function() { + cancelled = true; + stream.removeListener("complete", onfinish); + stream.removeListener("abort", onclose); + stream.removeListener("request", onrequest); + if (stream.req) + stream.req.removeListener("finish", onfinish); + stream.removeListener("end", onlegacyfinish); + stream.removeListener("close", onlegacyfinish); + stream.removeListener("finish", onfinish); + stream.removeListener("exit", onexit); + stream.removeListener("end", onend); + stream.removeListener("error", onerror); + stream.removeListener("close", onclose); + }; + }; + module.exports = eos; + } +}); + +// ../testeranto/node_modules/pump/index.js +var require_pump = __commonJS({ + "../testeranto/node_modules/pump/index.js"(exports, module) { + init_cjs_shim(); + var once = require_once(); + var eos = require_end_of_stream(); + var fs6; + try { + fs6 = __require("fs"); + } catch (e) { + } + var noop = function() { + }; + var ancient = /^v?\.0/.test(process.version); + var isFn = function(fn) { + return typeof fn === "function"; + }; + var isFS = function(stream) { + if (!ancient) + return false; + if (!fs6) + return false; + return (stream instanceof (fs6.ReadStream || noop) || stream instanceof (fs6.WriteStream || noop)) && isFn(stream.close); + }; + var isRequest = function(stream) { + return stream.setHeader && isFn(stream.abort); + }; + var destroyer = function(stream, reading, writing, callback) { + callback = once(callback); + var closed = false; + stream.on("close", function() { + closed = true; + }); + eos(stream, { readable: reading, writable: writing }, function(err) { + if (err) + return callback(err); + closed = true; + callback(); + }); + var destroyed = false; + return function(err) { + if (closed) + return; + if (destroyed) + return; + destroyed = true; + if (isFS(stream)) + return stream.close(noop); + if (isRequest(stream)) + return stream.abort(); + if (isFn(stream.destroy)) + return stream.destroy(); + callback(err || new Error("stream was destroyed")); + }; + }; + var call = function(fn) { + fn(); + }; + var pipe = function(from2, to) { + return from2.pipe(to); + }; + var pump = function() { + var streams = Array.prototype.slice.call(arguments); + var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop; + if (Array.isArray(streams[0])) + streams = streams[0]; + if (streams.length < 2) + throw new Error("pump requires two streams per minimum"); + var error; + var destroys = streams.map(function(stream, i) { + var reading = i < streams.length - 1; + var writing = i > 0; + return destroyer(stream, reading, writing, function(err) { + if (!error) + error = err; + if (err) + destroys.forEach(call); + if (reading) + return; + destroys.forEach(call); + callback(error); + }); + }); + return streams.reduce(pipe); + }; + module.exports = pump; + } +}); + +// ../testeranto/node_modules/get-stream/buffer-stream.js +var require_buffer_stream = __commonJS({ + "../testeranto/node_modules/get-stream/buffer-stream.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { PassThrough: PassThroughStream } = __require("stream"); + module.exports = (options) => { + options = { ...options }; + const { array } = options; + let { encoding } = options; + const isBuffer = encoding === "buffer"; + let objectMode = false; + if (array) { + objectMode = !(encoding || isBuffer); + } else { + encoding = encoding || "utf8"; + } + if (isBuffer) { + encoding = null; + } + const stream = new PassThroughStream({ objectMode }); + if (encoding) { + stream.setEncoding(encoding); + } + let length = 0; + const chunks = []; + stream.on("data", (chunk) => { + chunks.push(chunk); + if (objectMode) { + length = chunks.length; + } else { + length += chunk.length; + } + }); + stream.getBufferedValue = () => { + if (array) { + return chunks; + } + return isBuffer ? Buffer.concat(chunks, length) : chunks.join(""); + }; + stream.getBufferedLength = () => length; + return stream; + }; + } +}); + +// ../testeranto/node_modules/get-stream/index.js +var require_get_stream = __commonJS({ + "../testeranto/node_modules/get-stream/index.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { constants: BufferConstants } = __require("buffer"); + var pump = require_pump(); + var bufferStream = require_buffer_stream(); + var MaxBufferError = class extends Error { + constructor() { + super("maxBuffer exceeded"); + this.name = "MaxBufferError"; + } + }; + async function getStream(inputStream, options) { + if (!inputStream) { + return Promise.reject(new Error("Expected a stream")); + } + options = { + maxBuffer: Infinity, + ...options + }; + const { maxBuffer } = options; + let stream; + await new Promise((resolve5, reject) => { + const rejectPromise = (error) => { + if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) { + error.bufferedData = stream.getBufferedValue(); + } + reject(error); + }; + stream = pump(inputStream, bufferStream(options), (error) => { + if (error) { + rejectPromise(error); + return; + } + resolve5(); + }); + stream.on("data", () => { + if (stream.getBufferedLength() > maxBuffer) { + rejectPromise(new MaxBufferError()); + } + }); + }); + return stream.getBufferedValue(); + } + module.exports = getStream; + module.exports.default = getStream; + module.exports.buffer = (stream, options) => getStream(stream, { ...options, encoding: "buffer" }); + module.exports.array = (stream, options) => getStream(stream, { ...options, array: true }); + module.exports.MaxBufferError = MaxBufferError; + } +}); + +// ../testeranto/node_modules/pend/index.js +var require_pend = __commonJS({ + "../testeranto/node_modules/pend/index.js"(exports, module) { + init_cjs_shim(); + module.exports = Pend; + function Pend() { + this.pending = 0; + this.max = Infinity; + this.listeners = []; + this.waiting = []; + this.error = null; + } + Pend.prototype.go = function(fn) { + if (this.pending < this.max) { + pendGo(this, fn); + } else { + this.waiting.push(fn); + } + }; + Pend.prototype.wait = function(cb) { + if (this.pending === 0) { + cb(this.error); + } else { + this.listeners.push(cb); + } + }; + Pend.prototype.hold = function() { + return pendHold(this); + }; + function pendHold(self2) { + self2.pending += 1; + var called = false; + return onCb; + function onCb(err) { + if (called) + throw new Error("callback called twice"); + called = true; + self2.error = self2.error || err; + self2.pending -= 1; + if (self2.waiting.length > 0 && self2.pending < self2.max) { + pendGo(self2, self2.waiting.shift()); + } else if (self2.pending === 0) { + var listeners = self2.listeners; + self2.listeners = []; + listeners.forEach(cbListener); + } + } + function cbListener(listener) { + listener(self2.error); + } + } + function pendGo(self2, fn) { + fn(pendHold(self2)); + } + } +}); + +// ../testeranto/node_modules/fd-slicer/index.js +var require_fd_slicer = __commonJS({ + "../testeranto/node_modules/fd-slicer/index.js"(exports) { + init_cjs_shim(); + var fs6 = __require("fs"); + var util2 = __require("util"); + var stream = __require("stream"); + var Readable = stream.Readable; + var Writable = stream.Writable; + var PassThrough2 = stream.PassThrough; + var Pend = require_pend(); + var EventEmitter2 = __require("events").EventEmitter; + exports.createFromBuffer = createFromBuffer; + exports.createFromFd = createFromFd; + exports.BufferSlicer = BufferSlicer; + exports.FdSlicer = FdSlicer; + util2.inherits(FdSlicer, EventEmitter2); + function FdSlicer(fd, options) { + options = options || {}; + EventEmitter2.call(this); + this.fd = fd; + this.pend = new Pend(); + this.pend.max = 1; + this.refCount = 0; + this.autoClose = !!options.autoClose; + } + FdSlicer.prototype.read = function(buffer, offset, length, position, callback) { + var self2 = this; + self2.pend.go(function(cb) { + fs6.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) { + cb(); + callback(err, bytesRead, buffer2); + }); + }); + }; + FdSlicer.prototype.write = function(buffer, offset, length, position, callback) { + var self2 = this; + self2.pend.go(function(cb) { + fs6.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) { + cb(); + callback(err, written, buffer2); + }); + }); + }; + FdSlicer.prototype.createReadStream = function(options) { + return new ReadStream(this, options); + }; + FdSlicer.prototype.createWriteStream = function(options) { + return new WriteStream(this, options); + }; + FdSlicer.prototype.ref = function() { + this.refCount += 1; + }; + FdSlicer.prototype.unref = function() { + var self2 = this; + self2.refCount -= 1; + if (self2.refCount > 0) + return; + if (self2.refCount < 0) + throw new Error("invalid unref"); + if (self2.autoClose) { + fs6.close(self2.fd, onCloseDone); + } + function onCloseDone(err) { + if (err) { + self2.emit("error", err); + } else { + self2.emit("close"); + } + } + }; + util2.inherits(ReadStream, Readable); + function ReadStream(context, options) { + options = options || {}; + Readable.call(this, options); + this.context = context; + this.context.ref(); + this.start = options.start || 0; + this.endOffset = options.end; + this.pos = this.start; + this.destroyed = false; + } + ReadStream.prototype._read = function(n) { + var self2 = this; + if (self2.destroyed) + return; + var toRead = Math.min(self2._readableState.highWaterMark, n); + if (self2.endOffset != null) { + toRead = Math.min(toRead, self2.endOffset - self2.pos); + } + if (toRead <= 0) { + self2.destroyed = true; + self2.push(null); + self2.context.unref(); + return; + } + self2.context.pend.go(function(cb) { + if (self2.destroyed) + return cb(); + var buffer = new Buffer(toRead); + fs6.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) { + if (err) { + self2.destroy(err); + } else if (bytesRead === 0) { + self2.destroyed = true; + self2.push(null); + self2.context.unref(); + } else { + self2.pos += bytesRead; + self2.push(buffer.slice(0, bytesRead)); + } + cb(); + }); + }); + }; + ReadStream.prototype.destroy = function(err) { + if (this.destroyed) + return; + err = err || new Error("stream destroyed"); + this.destroyed = true; + this.emit("error", err); + this.context.unref(); + }; + util2.inherits(WriteStream, Writable); + function WriteStream(context, options) { + options = options || {}; + Writable.call(this, options); + this.context = context; + this.context.ref(); + this.start = options.start || 0; + this.endOffset = options.end == null ? Infinity : +options.end; + this.bytesWritten = 0; + this.pos = this.start; + this.destroyed = false; + this.on("finish", this.destroy.bind(this)); + } + WriteStream.prototype._write = function(buffer, encoding, callback) { + var self2 = this; + if (self2.destroyed) + return; + if (self2.pos + buffer.length > self2.endOffset) { + var err = new Error("maximum file length exceeded"); + err.code = "ETOOBIG"; + self2.destroy(); + callback(err); + return; + } + self2.context.pend.go(function(cb) { + if (self2.destroyed) + return cb(); + fs6.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) { + if (err2) { + self2.destroy(); + cb(); + callback(err2); + } else { + self2.bytesWritten += bytes; + self2.pos += bytes; + self2.emit("progress"); + cb(); + callback(); + } + }); + }); + }; + WriteStream.prototype.destroy = function() { + if (this.destroyed) + return; + this.destroyed = true; + this.context.unref(); + }; + util2.inherits(BufferSlicer, EventEmitter2); + function BufferSlicer(buffer, options) { + EventEmitter2.call(this); + options = options || {}; + this.refCount = 0; + this.buffer = buffer; + this.maxChunkSize = options.maxChunkSize || Number.MAX_SAFE_INTEGER; + } + BufferSlicer.prototype.read = function(buffer, offset, length, position, callback) { + var end = position + length; + var delta = end - this.buffer.length; + var written = delta > 0 ? delta : length; + this.buffer.copy(buffer, offset, position, end); + setImmediate(function() { + callback(null, written); + }); + }; + BufferSlicer.prototype.write = function(buffer, offset, length, position, callback) { + buffer.copy(this.buffer, position, offset, offset + length); + setImmediate(function() { + callback(null, length, buffer); + }); + }; + BufferSlicer.prototype.createReadStream = function(options) { + options = options || {}; + var readStream = new PassThrough2(options); + readStream.destroyed = false; + readStream.start = options.start || 0; + readStream.endOffset = options.end; + readStream.pos = readStream.endOffset || this.buffer.length; + var entireSlice = this.buffer.slice(readStream.start, readStream.pos); + var offset = 0; + while (true) { + var nextOffset = offset + this.maxChunkSize; + if (nextOffset >= entireSlice.length) { + if (offset < entireSlice.length) { + readStream.write(entireSlice.slice(offset, entireSlice.length)); + } + break; + } + readStream.write(entireSlice.slice(offset, nextOffset)); + offset = nextOffset; + } + readStream.end(); + readStream.destroy = function() { + readStream.destroyed = true; + }; + return readStream; + }; + BufferSlicer.prototype.createWriteStream = function(options) { + var bufferSlicer = this; + options = options || {}; + var writeStream = new Writable(options); + writeStream.start = options.start || 0; + writeStream.endOffset = options.end == null ? this.buffer.length : +options.end; + writeStream.bytesWritten = 0; + writeStream.pos = writeStream.start; + writeStream.destroyed = false; + writeStream._write = function(buffer, encoding, callback) { + if (writeStream.destroyed) + return; + var end = writeStream.pos + buffer.length; + if (end > writeStream.endOffset) { + var err = new Error("maximum file length exceeded"); + err.code = "ETOOBIG"; + writeStream.destroyed = true; + callback(err); + return; + } + buffer.copy(bufferSlicer.buffer, writeStream.pos, 0, buffer.length); + writeStream.bytesWritten += buffer.length; + writeStream.pos = end; + writeStream.emit("progress"); + callback(); + }; + writeStream.destroy = function() { + writeStream.destroyed = true; + }; + return writeStream; + }; + BufferSlicer.prototype.ref = function() { + this.refCount += 1; + }; + BufferSlicer.prototype.unref = function() { + this.refCount -= 1; + if (this.refCount < 0) { + throw new Error("invalid unref"); + } + }; + function createFromBuffer(buffer, options) { + return new BufferSlicer(buffer, options); + } + function createFromFd(fd, options) { + return new FdSlicer(fd, options); + } + } +}); + +// ../testeranto/node_modules/buffer-crc32/index.js +var require_buffer_crc32 = __commonJS({ + "../testeranto/node_modules/buffer-crc32/index.js"(exports, module) { + init_cjs_shim(); + var Buffer2 = __require("buffer").Buffer; + var CRC_TABLE = [ + 0, + 1996959894, + 3993919788, + 2567524794, + 124634137, + 1886057615, + 3915621685, + 2657392035, + 249268274, + 2044508324, + 3772115230, + 2547177864, + 162941995, + 2125561021, + 3887607047, + 2428444049, + 498536548, + 1789927666, + 4089016648, + 2227061214, + 450548861, + 1843258603, + 4107580753, + 2211677639, + 325883990, + 1684777152, + 4251122042, + 2321926636, + 335633487, + 1661365465, + 4195302755, + 2366115317, + 997073096, + 1281953886, + 3579855332, + 2724688242, + 1006888145, + 1258607687, + 3524101629, + 2768942443, + 901097722, + 1119000684, + 3686517206, + 2898065728, + 853044451, + 1172266101, + 3705015759, + 2882616665, + 651767980, + 1373503546, + 3369554304, + 3218104598, + 565507253, + 1454621731, + 3485111705, + 3099436303, + 671266974, + 1594198024, + 3322730930, + 2970347812, + 795835527, + 1483230225, + 3244367275, + 3060149565, + 1994146192, + 31158534, + 2563907772, + 4023717930, + 1907459465, + 112637215, + 2680153253, + 3904427059, + 2013776290, + 251722036, + 2517215374, + 3775830040, + 2137656763, + 141376813, + 2439277719, + 3865271297, + 1802195444, + 476864866, + 2238001368, + 4066508878, + 1812370925, + 453092731, + 2181625025, + 4111451223, + 1706088902, + 314042704, + 2344532202, + 4240017532, + 1658658271, + 366619977, + 2362670323, + 4224994405, + 1303535960, + 984961486, + 2747007092, + 3569037538, + 1256170817, + 1037604311, + 2765210733, + 3554079995, + 1131014506, + 879679996, + 2909243462, + 3663771856, + 1141124467, + 855842277, + 2852801631, + 3708648649, + 1342533948, + 654459306, + 3188396048, + 3373015174, + 1466479909, + 544179635, + 3110523913, + 3462522015, + 1591671054, + 702138776, + 2966460450, + 3352799412, + 1504918807, + 783551873, + 3082640443, + 3233442989, + 3988292384, + 2596254646, + 62317068, + 1957810842, + 3939845945, + 2647816111, + 81470997, + 1943803523, + 3814918930, + 2489596804, + 225274430, + 2053790376, + 3826175755, + 2466906013, + 167816743, + 2097651377, + 4027552580, + 2265490386, + 503444072, + 1762050814, + 4150417245, + 2154129355, + 426522225, + 1852507879, + 4275313526, + 2312317920, + 282753626, + 1742555852, + 4189708143, + 2394877945, + 397917763, + 1622183637, + 3604390888, + 2714866558, + 953729732, + 1340076626, + 3518719985, + 2797360999, + 1068828381, + 1219638859, + 3624741850, + 2936675148, + 906185462, + 1090812512, + 3747672003, + 2825379669, + 829329135, + 1181335161, + 3412177804, + 3160834842, + 628085408, + 1382605366, + 3423369109, + 3138078467, + 570562233, + 1426400815, + 3317316542, + 2998733608, + 733239954, + 1555261956, + 3268935591, + 3050360625, + 752459403, + 1541320221, + 2607071920, + 3965973030, + 1969922972, + 40735498, + 2617837225, + 3943577151, + 1913087877, + 83908371, + 2512341634, + 3803740692, + 2075208622, + 213261112, + 2463272603, + 3855990285, + 2094854071, + 198958881, + 2262029012, + 4057260610, + 1759359992, + 534414190, + 2176718541, + 4139329115, + 1873836001, + 414664567, + 2282248934, + 4279200368, + 1711684554, + 285281116, + 2405801727, + 4167216745, + 1634467795, + 376229701, + 2685067896, + 3608007406, + 1308918612, + 956543938, + 2808555105, + 3495958263, + 1231636301, + 1047427035, + 2932959818, + 3654703836, + 1088359270, + 936918e3, + 2847714899, + 3736837829, + 1202900863, + 817233897, + 3183342108, + 3401237130, + 1404277552, + 615818150, + 3134207493, + 3453421203, + 1423857449, + 601450431, + 3009837614, + 3294710456, + 1567103746, + 711928724, + 3020668471, + 3272380065, + 1510334235, + 755167117 + ]; + if (typeof Int32Array !== "undefined") { + CRC_TABLE = new Int32Array(CRC_TABLE); + } + function ensureBuffer(input) { + if (Buffer2.isBuffer(input)) { + return input; + } + var hasNewBufferAPI = typeof Buffer2.alloc === "function" && typeof Buffer2.from === "function"; + if (typeof input === "number") { + return hasNewBufferAPI ? Buffer2.alloc(input) : new Buffer2(input); + } else if (typeof input === "string") { + return hasNewBufferAPI ? Buffer2.from(input) : new Buffer2(input); + } else { + throw new Error("input must be buffer, number, or string, received " + typeof input); + } + } + function bufferizeInt(num) { + var tmp = ensureBuffer(4); + tmp.writeInt32BE(num, 0); + return tmp; + } + function _crc32(buf, previous) { + buf = ensureBuffer(buf); + if (Buffer2.isBuffer(previous)) { + previous = previous.readUInt32BE(0); + } + var crc = ~~previous ^ -1; + for (var n = 0; n < buf.length; n++) { + crc = CRC_TABLE[(crc ^ buf[n]) & 255] ^ crc >>> 8; + } + return crc ^ -1; + } + function crc32() { + return bufferizeInt(_crc32.apply(null, arguments)); + } + crc32.signed = function() { + return _crc32.apply(null, arguments); + }; + crc32.unsigned = function() { + return _crc32.apply(null, arguments) >>> 0; + }; + module.exports = crc32; + } +}); + +// ../testeranto/node_modules/yauzl/index.js +var require_yauzl = __commonJS({ + "../testeranto/node_modules/yauzl/index.js"(exports) { + init_cjs_shim(); + var fs6 = __require("fs"); + var zlib = __require("zlib"); + var fd_slicer = require_fd_slicer(); + var crc32 = require_buffer_crc32(); + var util2 = __require("util"); + var EventEmitter2 = __require("events").EventEmitter; + var Transform = __require("stream").Transform; + var PassThrough2 = __require("stream").PassThrough; + var Writable = __require("stream").Writable; + exports.open = open; + exports.fromFd = fromFd; + exports.fromBuffer = fromBuffer; + exports.fromRandomAccessReader = fromRandomAccessReader; + exports.dosDateTimeToDate = dosDateTimeToDate; + exports.validateFileName = validateFileName; + exports.ZipFile = ZipFile; + exports.Entry = Entry; + exports.RandomAccessReader = RandomAccessReader; + function open(path10, options, callback) { + if (typeof options === "function") { + callback = options; + options = null; + } + if (options == null) + options = {}; + if (options.autoClose == null) + options.autoClose = true; + if (options.lazyEntries == null) + options.lazyEntries = false; + if (options.decodeStrings == null) + options.decodeStrings = true; + if (options.validateEntrySizes == null) + options.validateEntrySizes = true; + if (options.strictFileNames == null) + options.strictFileNames = false; + if (callback == null) + callback = defaultCallback; + fs6.open(path10, "r", function(err, fd) { + if (err) + return callback(err); + fromFd(fd, options, function(err2, zipfile) { + if (err2) + fs6.close(fd, defaultCallback); + callback(err2, zipfile); + }); + }); + } + function fromFd(fd, options, callback) { + if (typeof options === "function") { + callback = options; + options = null; + } + if (options == null) + options = {}; + if (options.autoClose == null) + options.autoClose = false; + if (options.lazyEntries == null) + options.lazyEntries = false; + if (options.decodeStrings == null) + options.decodeStrings = true; + if (options.validateEntrySizes == null) + options.validateEntrySizes = true; + if (options.strictFileNames == null) + options.strictFileNames = false; + if (callback == null) + callback = defaultCallback; + fs6.fstat(fd, function(err, stats) { + if (err) + return callback(err); + var reader = fd_slicer.createFromFd(fd, { autoClose: true }); + fromRandomAccessReader(reader, stats.size, options, callback); + }); + } + function fromBuffer(buffer, options, callback) { + if (typeof options === "function") { + callback = options; + options = null; + } + if (options == null) + options = {}; + options.autoClose = false; + if (options.lazyEntries == null) + options.lazyEntries = false; + if (options.decodeStrings == null) + options.decodeStrings = true; + if (options.validateEntrySizes == null) + options.validateEntrySizes = true; + if (options.strictFileNames == null) + options.strictFileNames = false; + var reader = fd_slicer.createFromBuffer(buffer, { maxChunkSize: 65536 }); + fromRandomAccessReader(reader, buffer.length, options, callback); + } + function fromRandomAccessReader(reader, totalSize, options, callback) { + if (typeof options === "function") { + callback = options; + options = null; + } + if (options == null) + options = {}; + if (options.autoClose == null) + options.autoClose = true; + if (options.lazyEntries == null) + options.lazyEntries = false; + if (options.decodeStrings == null) + options.decodeStrings = true; + var decodeStrings = !!options.decodeStrings; + if (options.validateEntrySizes == null) + options.validateEntrySizes = true; + if (options.strictFileNames == null) + options.strictFileNames = false; + if (callback == null) + callback = defaultCallback; + if (typeof totalSize !== "number") + throw new Error("expected totalSize parameter to be a number"); + if (totalSize > Number.MAX_SAFE_INTEGER) { + throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double."); + } + reader.ref(); + var eocdrWithoutCommentSize = 22; + var maxCommentSize = 65535; + var bufferSize = Math.min(eocdrWithoutCommentSize + maxCommentSize, totalSize); + var buffer = newBuffer(bufferSize); + var bufferReadStart = totalSize - buffer.length; + readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) { + if (err) + return callback(err); + for (var i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) { + if (buffer.readUInt32LE(i) !== 101010256) + continue; + var eocdrBuffer = buffer.slice(i); + var diskNumber = eocdrBuffer.readUInt16LE(4); + if (diskNumber !== 0) { + return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber)); + } + var entryCount = eocdrBuffer.readUInt16LE(10); + var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16); + var commentLength = eocdrBuffer.readUInt16LE(20); + var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize; + if (commentLength !== expectedCommentLength) { + return callback(new Error("invalid comment length. expected: " + expectedCommentLength + ". found: " + commentLength)); + } + var comment = decodeStrings ? decodeBuffer(eocdrBuffer, 22, eocdrBuffer.length, false) : eocdrBuffer.slice(22); + if (!(entryCount === 65535 || centralDirectoryOffset === 4294967295)) { + return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames)); + } + var zip64EocdlBuffer = newBuffer(20); + var zip64EocdlOffset = bufferReadStart + i - zip64EocdlBuffer.length; + readAndAssertNoEof(reader, zip64EocdlBuffer, 0, zip64EocdlBuffer.length, zip64EocdlOffset, function(err2) { + if (err2) + return callback(err2); + if (zip64EocdlBuffer.readUInt32LE(0) !== 117853008) { + return callback(new Error("invalid zip64 end of central directory locator signature")); + } + var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8); + var zip64EocdrBuffer = newBuffer(56); + readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err3) { + if (err3) + return callback(err3); + if (zip64EocdrBuffer.readUInt32LE(0) !== 101075792) { + return callback(new Error("invalid zip64 end of central directory record signature")); + } + entryCount = readUInt64LE(zip64EocdrBuffer, 32); + centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48); + return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames)); + }); + }); + return; + } + callback(new Error("end of central directory record signature not found")); + }); + } + util2.inherits(ZipFile, EventEmitter2); + function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) { + var self2 = this; + EventEmitter2.call(self2); + self2.reader = reader; + self2.reader.on("error", function(err) { + emitError(self2, err); + }); + self2.reader.once("close", function() { + self2.emit("close"); + }); + self2.readEntryCursor = centralDirectoryOffset; + self2.fileSize = fileSize; + self2.entryCount = entryCount; + self2.comment = comment; + self2.entriesRead = 0; + self2.autoClose = !!autoClose; + self2.lazyEntries = !!lazyEntries; + self2.decodeStrings = !!decodeStrings; + self2.validateEntrySizes = !!validateEntrySizes; + self2.strictFileNames = !!strictFileNames; + self2.isOpen = true; + self2.emittedError = false; + if (!self2.lazyEntries) + self2._readEntry(); + } + ZipFile.prototype.close = function() { + if (!this.isOpen) + return; + this.isOpen = false; + this.reader.unref(); + }; + function emitErrorAndAutoClose(self2, err) { + if (self2.autoClose) + self2.close(); + emitError(self2, err); + } + function emitError(self2, err) { + if (self2.emittedError) + return; + self2.emittedError = true; + self2.emit("error", err); + } + ZipFile.prototype.readEntry = function() { + if (!this.lazyEntries) + throw new Error("readEntry() called without lazyEntries:true"); + this._readEntry(); + }; + ZipFile.prototype._readEntry = function() { + var self2 = this; + if (self2.entryCount === self2.entriesRead) { + setImmediate(function() { + if (self2.autoClose) + self2.close(); + if (self2.emittedError) + return; + self2.emit("end"); + }); + return; + } + if (self2.emittedError) + return; + var buffer = newBuffer(46); + readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err) { + if (err) + return emitErrorAndAutoClose(self2, err); + if (self2.emittedError) + return; + var entry = new Entry(); + var signature = buffer.readUInt32LE(0); + if (signature !== 33639248) + return emitErrorAndAutoClose(self2, new Error("invalid central directory file header signature: 0x" + signature.toString(16))); + entry.versionMadeBy = buffer.readUInt16LE(4); + entry.versionNeededToExtract = buffer.readUInt16LE(6); + entry.generalPurposeBitFlag = buffer.readUInt16LE(8); + entry.compressionMethod = buffer.readUInt16LE(10); + entry.lastModFileTime = buffer.readUInt16LE(12); + entry.lastModFileDate = buffer.readUInt16LE(14); + entry.crc32 = buffer.readUInt32LE(16); + entry.compressedSize = buffer.readUInt32LE(20); + entry.uncompressedSize = buffer.readUInt32LE(24); + entry.fileNameLength = buffer.readUInt16LE(28); + entry.extraFieldLength = buffer.readUInt16LE(30); + entry.fileCommentLength = buffer.readUInt16LE(32); + entry.internalFileAttributes = buffer.readUInt16LE(36); + entry.externalFileAttributes = buffer.readUInt32LE(38); + entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42); + if (entry.generalPurposeBitFlag & 64) + return emitErrorAndAutoClose(self2, new Error("strong encryption is not supported")); + self2.readEntryCursor += 46; + buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength); + readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err2) { + if (err2) + return emitErrorAndAutoClose(self2, err2); + if (self2.emittedError) + return; + var isUtf8 = (entry.generalPurposeBitFlag & 2048) !== 0; + entry.fileName = self2.decodeStrings ? decodeBuffer(buffer, 0, entry.fileNameLength, isUtf8) : buffer.slice(0, entry.fileNameLength); + var fileCommentStart = entry.fileNameLength + entry.extraFieldLength; + var extraFieldBuffer = buffer.slice(entry.fileNameLength, fileCommentStart); + entry.extraFields = []; + var i = 0; + while (i < extraFieldBuffer.length - 3) { + var headerId = extraFieldBuffer.readUInt16LE(i + 0); + var dataSize = extraFieldBuffer.readUInt16LE(i + 2); + var dataStart = i + 4; + var dataEnd = dataStart + dataSize; + if (dataEnd > extraFieldBuffer.length) + return emitErrorAndAutoClose(self2, new Error("extra field length exceeds extra field buffer size")); + var dataBuffer = newBuffer(dataSize); + extraFieldBuffer.copy(dataBuffer, 0, dataStart, dataEnd); + entry.extraFields.push({ + id: headerId, + data: dataBuffer + }); + i = dataEnd; + } + entry.fileComment = self2.decodeStrings ? decodeBuffer(buffer, fileCommentStart, fileCommentStart + entry.fileCommentLength, isUtf8) : buffer.slice(fileCommentStart, fileCommentStart + entry.fileCommentLength); + entry.comment = entry.fileComment; + self2.readEntryCursor += buffer.length; + self2.entriesRead += 1; + if (entry.uncompressedSize === 4294967295 || entry.compressedSize === 4294967295 || entry.relativeOffsetOfLocalHeader === 4294967295) { + var zip64EiefBuffer = null; + for (var i = 0; i < entry.extraFields.length; i++) { + var extraField = entry.extraFields[i]; + if (extraField.id === 1) { + zip64EiefBuffer = extraField.data; + break; + } + } + if (zip64EiefBuffer == null) { + return emitErrorAndAutoClose(self2, new Error("expected zip64 extended information extra field")); + } + var index = 0; + if (entry.uncompressedSize === 4294967295) { + if (index + 8 > zip64EiefBuffer.length) { + return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include uncompressed size")); + } + entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index); + index += 8; + } + if (entry.compressedSize === 4294967295) { + if (index + 8 > zip64EiefBuffer.length) { + return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include compressed size")); + } + entry.compressedSize = readUInt64LE(zip64EiefBuffer, index); + index += 8; + } + if (entry.relativeOffsetOfLocalHeader === 4294967295) { + if (index + 8 > zip64EiefBuffer.length) { + return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include relative header offset")); + } + entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index); + index += 8; + } + } + if (self2.decodeStrings) { + for (var i = 0; i < entry.extraFields.length; i++) { + var extraField = entry.extraFields[i]; + if (extraField.id === 28789) { + if (extraField.data.length < 6) { + continue; + } + if (extraField.data.readUInt8(0) !== 1) { + continue; + } + var oldNameCrc32 = extraField.data.readUInt32LE(1); + if (crc32.unsigned(buffer.slice(0, entry.fileNameLength)) !== oldNameCrc32) { + continue; + } + entry.fileName = decodeBuffer(extraField.data, 5, extraField.data.length, true); + break; + } + } + } + if (self2.validateEntrySizes && entry.compressionMethod === 0) { + var expectedCompressedSize = entry.uncompressedSize; + if (entry.isEncrypted()) { + expectedCompressedSize += 12; + } + if (entry.compressedSize !== expectedCompressedSize) { + var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize; + return emitErrorAndAutoClose(self2, new Error(msg)); + } + } + if (self2.decodeStrings) { + if (!self2.strictFileNames) { + entry.fileName = entry.fileName.replace(/\\/g, "/"); + } + var errorMessage = validateFileName(entry.fileName, self2.validateFileNameOptions); + if (errorMessage != null) + return emitErrorAndAutoClose(self2, new Error(errorMessage)); + } + self2.emit("entry", entry); + if (!self2.lazyEntries) + self2._readEntry(); + }); + }); + }; + ZipFile.prototype.openReadStream = function(entry, options, callback) { + var self2 = this; + var relativeStart = 0; + var relativeEnd = entry.compressedSize; + if (callback == null) { + callback = options; + options = {}; + } else { + if (options.decrypt != null) { + if (!entry.isEncrypted()) { + throw new Error("options.decrypt can only be specified for encrypted entries"); + } + if (options.decrypt !== false) + throw new Error("invalid options.decrypt value: " + options.decrypt); + if (entry.isCompressed()) { + if (options.decompress !== false) + throw new Error("entry is encrypted and compressed, and options.decompress !== false"); + } + } + if (options.decompress != null) { + if (!entry.isCompressed()) { + throw new Error("options.decompress can only be specified for compressed entries"); + } + if (!(options.decompress === false || options.decompress === true)) { + throw new Error("invalid options.decompress value: " + options.decompress); + } + } + if (options.start != null || options.end != null) { + if (entry.isCompressed() && options.decompress !== false) { + throw new Error("start/end range not allowed for compressed entry without options.decompress === false"); + } + if (entry.isEncrypted() && options.decrypt !== false) { + throw new Error("start/end range not allowed for encrypted entry without options.decrypt === false"); + } + } + if (options.start != null) { + relativeStart = options.start; + if (relativeStart < 0) + throw new Error("options.start < 0"); + if (relativeStart > entry.compressedSize) + throw new Error("options.start > entry.compressedSize"); + } + if (options.end != null) { + relativeEnd = options.end; + if (relativeEnd < 0) + throw new Error("options.end < 0"); + if (relativeEnd > entry.compressedSize) + throw new Error("options.end > entry.compressedSize"); + if (relativeEnd < relativeStart) + throw new Error("options.end < options.start"); + } + } + if (!self2.isOpen) + return callback(new Error("closed")); + if (entry.isEncrypted()) { + if (options.decrypt !== false) + return callback(new Error("entry is encrypted, and options.decrypt !== false")); + } + self2.reader.ref(); + var buffer = newBuffer(30); + readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) { + try { + if (err) + return callback(err); + var signature = buffer.readUInt32LE(0); + if (signature !== 67324752) { + return callback(new Error("invalid local file header signature: 0x" + signature.toString(16))); + } + var fileNameLength = buffer.readUInt16LE(26); + var extraFieldLength = buffer.readUInt16LE(28); + var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength; + var decompress; + if (entry.compressionMethod === 0) { + decompress = false; + } else if (entry.compressionMethod === 8) { + decompress = options.decompress != null ? options.decompress : true; + } else { + return callback(new Error("unsupported compression method: " + entry.compressionMethod)); + } + var fileDataStart = localFileHeaderEnd; + var fileDataEnd = fileDataStart + entry.compressedSize; + if (entry.compressedSize !== 0) { + if (fileDataEnd > self2.fileSize) { + return callback(new Error("file data overflows file bounds: " + fileDataStart + " + " + entry.compressedSize + " > " + self2.fileSize)); + } + } + var readStream = self2.reader.createReadStream({ + start: fileDataStart + relativeStart, + end: fileDataStart + relativeEnd + }); + var endpointStream = readStream; + if (decompress) { + var destroyed = false; + var inflateFilter = zlib.createInflateRaw(); + readStream.on("error", function(err2) { + setImmediate(function() { + if (!destroyed) + inflateFilter.emit("error", err2); + }); + }); + readStream.pipe(inflateFilter); + if (self2.validateEntrySizes) { + endpointStream = new AssertByteCountStream(entry.uncompressedSize); + inflateFilter.on("error", function(err2) { + setImmediate(function() { + if (!destroyed) + endpointStream.emit("error", err2); + }); + }); + inflateFilter.pipe(endpointStream); + } else { + endpointStream = inflateFilter; + } + endpointStream.destroy = function() { + destroyed = true; + if (inflateFilter !== endpointStream) + inflateFilter.unpipe(endpointStream); + readStream.unpipe(inflateFilter); + readStream.destroy(); + }; + } + callback(null, endpointStream); + } finally { + self2.reader.unref(); + } + }); + }; + function Entry() { + } + Entry.prototype.getLastModDate = function() { + return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime); + }; + Entry.prototype.isEncrypted = function() { + return (this.generalPurposeBitFlag & 1) !== 0; + }; + Entry.prototype.isCompressed = function() { + return this.compressionMethod === 8; + }; + function dosDateTimeToDate(date, time) { + var day = date & 31; + var month = (date >> 5 & 15) - 1; + var year = (date >> 9 & 127) + 1980; + var millisecond = 0; + var second = (time & 31) * 2; + var minute = time >> 5 & 63; + var hour = time >> 11 & 31; + return new Date(year, month, day, hour, minute, second, millisecond); + } + function validateFileName(fileName) { + if (fileName.indexOf("\\") !== -1) { + return "invalid characters in fileName: " + fileName; + } + if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) { + return "absolute path: " + fileName; + } + if (fileName.split("/").indexOf("..") !== -1) { + return "invalid relative path: " + fileName; + } + return null; + } + function readAndAssertNoEof(reader, buffer, offset, length, position, callback) { + if (length === 0) { + return setImmediate(function() { + callback(null, newBuffer(0)); + }); + } + reader.read(buffer, offset, length, position, function(err, bytesRead) { + if (err) + return callback(err); + if (bytesRead < length) { + return callback(new Error("unexpected EOF")); + } + callback(); + }); + } + util2.inherits(AssertByteCountStream, Transform); + function AssertByteCountStream(byteCount) { + Transform.call(this); + this.actualByteCount = 0; + this.expectedByteCount = byteCount; + } + AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) { + this.actualByteCount += chunk.length; + if (this.actualByteCount > this.expectedByteCount) { + var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount; + return cb(new Error(msg)); + } + cb(null, chunk); + }; + AssertByteCountStream.prototype._flush = function(cb) { + if (this.actualByteCount < this.expectedByteCount) { + var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount; + return cb(new Error(msg)); + } + cb(); + }; + util2.inherits(RandomAccessReader, EventEmitter2); + function RandomAccessReader() { + EventEmitter2.call(this); + this.refCount = 0; + } + RandomAccessReader.prototype.ref = function() { + this.refCount += 1; + }; + RandomAccessReader.prototype.unref = function() { + var self2 = this; + self2.refCount -= 1; + if (self2.refCount > 0) + return; + if (self2.refCount < 0) + throw new Error("invalid unref"); + self2.close(onCloseDone); + function onCloseDone(err) { + if (err) + return self2.emit("error", err); + self2.emit("close"); + } + }; + RandomAccessReader.prototype.createReadStream = function(options) { + var start = options.start; + var end = options.end; + if (start === end) { + var emptyStream = new PassThrough2(); + setImmediate(function() { + emptyStream.end(); + }); + return emptyStream; + } + var stream = this._readStreamForRange(start, end); + var destroyed = false; + var refUnrefFilter = new RefUnrefFilter(this); + stream.on("error", function(err) { + setImmediate(function() { + if (!destroyed) + refUnrefFilter.emit("error", err); + }); + }); + refUnrefFilter.destroy = function() { + stream.unpipe(refUnrefFilter); + refUnrefFilter.unref(); + stream.destroy(); + }; + var byteCounter = new AssertByteCountStream(end - start); + refUnrefFilter.on("error", function(err) { + setImmediate(function() { + if (!destroyed) + byteCounter.emit("error", err); + }); + }); + byteCounter.destroy = function() { + destroyed = true; + refUnrefFilter.unpipe(byteCounter); + refUnrefFilter.destroy(); + }; + return stream.pipe(refUnrefFilter).pipe(byteCounter); + }; + RandomAccessReader.prototype._readStreamForRange = function(start, end) { + throw new Error("not implemented"); + }; + RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) { + var readStream = this.createReadStream({ start: position, end: position + length }); + var writeStream = new Writable(); + var written = 0; + writeStream._write = function(chunk, encoding, cb) { + chunk.copy(buffer, offset + written, 0, chunk.length); + written += chunk.length; + cb(); + }; + writeStream.on("finish", callback); + readStream.on("error", function(error) { + callback(error); + }); + readStream.pipe(writeStream); + }; + RandomAccessReader.prototype.close = function(callback) { + setImmediate(callback); + }; + util2.inherits(RefUnrefFilter, PassThrough2); + function RefUnrefFilter(context) { + PassThrough2.call(this); + this.context = context; + this.context.ref(); + this.unreffedYet = false; + } + RefUnrefFilter.prototype._flush = function(cb) { + this.unref(); + cb(); + }; + RefUnrefFilter.prototype.unref = function(cb) { + if (this.unreffedYet) + return; + this.unreffedYet = true; + this.context.unref(); + }; + var cp437 = "\0\u263A\u263B\u2665\u2666\u2663\u2660\u2022\u25D8\u25CB\u25D9\u2642\u2640\u266A\u266B\u263C\u25BA\u25C4\u2195\u203C\xB6\xA7\u25AC\u21A8\u2191\u2193\u2192\u2190\u221F\u2194\u25B2\u25BC !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u2302\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"; + function decodeBuffer(buffer, start, end, isUtf8) { + if (isUtf8) { + return buffer.toString("utf8", start, end); + } else { + var result = ""; + for (var i = start; i < end; i++) { + result += cp437[buffer[i]]; + } + return result; + } + } + function readUInt64LE(buffer, offset) { + var lower32 = buffer.readUInt32LE(offset); + var upper32 = buffer.readUInt32LE(offset + 4); + return upper32 * 4294967296 + lower32; + } + var newBuffer; + if (typeof Buffer.allocUnsafe === "function") { + newBuffer = function(len) { + return Buffer.allocUnsafe(len); + }; + } else { + newBuffer = function(len) { + return new Buffer(len); + }; + } + function defaultCallback(err) { + if (err) + throw err; + } + } +}); + +// ../testeranto/node_modules/extract-zip/index.js +var require_extract_zip = __commonJS({ + "../testeranto/node_modules/extract-zip/index.js"(exports, module) { + init_cjs_shim(); + var debug5 = require_src()("extract-zip"); + var { createWriteStream, promises: fs6 } = __require("fs"); + var getStream = require_get_stream(); + var path10 = __require("path"); + var { promisify } = __require("util"); + var stream = __require("stream"); + var yauzl = require_yauzl(); + var openZip = promisify(yauzl.open); + var pipeline = promisify(stream.pipeline); + var Extractor = class { + constructor(zipPath, opts) { + this.zipPath = zipPath; + this.opts = opts; + } + async extract() { + debug5("opening", this.zipPath, "with opts", this.opts); + this.zipfile = await openZip(this.zipPath, { lazyEntries: true }); + this.canceled = false; + return new Promise((resolve5, reject) => { + this.zipfile.on("error", (err) => { + this.canceled = true; + reject(err); + }); + this.zipfile.readEntry(); + this.zipfile.on("close", () => { + if (!this.canceled) { + debug5("zip extraction complete"); + resolve5(); + } + }); + this.zipfile.on("entry", async (entry) => { + if (this.canceled) { + debug5("skipping entry", entry.fileName, { cancelled: this.canceled }); + return; + } + debug5("zipfile entry", entry.fileName); + if (entry.fileName.startsWith("__MACOSX/")) { + this.zipfile.readEntry(); + return; + } + const destDir = path10.dirname(path10.join(this.opts.dir, entry.fileName)); + try { + await fs6.mkdir(destDir, { recursive: true }); + const canonicalDestDir = await fs6.realpath(destDir); + const relativeDestDir = path10.relative(this.opts.dir, canonicalDestDir); + if (relativeDestDir.split(path10.sep).includes("..")) { + throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`); + } + await this.extractEntry(entry); + debug5("finished processing", entry.fileName); + this.zipfile.readEntry(); + } catch (err) { + this.canceled = true; + this.zipfile.close(); + reject(err); + } + }); + }); + } + async extractEntry(entry) { + if (this.canceled) { + debug5("skipping entry extraction", entry.fileName, { cancelled: this.canceled }); + return; + } + if (this.opts.onEntry) { + this.opts.onEntry(entry, this.zipfile); + } + const dest = path10.join(this.opts.dir, entry.fileName); + const mode = entry.externalFileAttributes >> 16 & 65535; + const IFMT = 61440; + const IFDIR = 16384; + const IFLNK = 40960; + const symlink = (mode & IFMT) === IFLNK; + let isDir = (mode & IFMT) === IFDIR; + if (!isDir && entry.fileName.endsWith("/")) { + isDir = true; + } + const madeBy = entry.versionMadeBy >> 8; + if (!isDir) + isDir = madeBy === 0 && entry.externalFileAttributes === 16; + debug5("extracting entry", { filename: entry.fileName, isDir, isSymlink: symlink }); + const procMode = this.getExtractedMode(mode, isDir) & 511; + const destDir = isDir ? dest : path10.dirname(dest); + const mkdirOptions = { recursive: true }; + if (isDir) { + mkdirOptions.mode = procMode; + } + debug5("mkdir", { dir: destDir, ...mkdirOptions }); + await fs6.mkdir(destDir, mkdirOptions); + if (isDir) + return; + debug5("opening read stream", dest); + const readStream = await promisify(this.zipfile.openReadStream.bind(this.zipfile))(entry); + if (symlink) { + const link = await getStream(readStream); + debug5("creating symlink", link, dest); + await fs6.symlink(link, dest); + } else { + await pipeline(readStream, createWriteStream(dest, { mode: procMode })); + } + } + getExtractedMode(entryMode, isDir) { + let mode = entryMode; + if (mode === 0) { + if (isDir) { + if (this.opts.defaultDirMode) { + mode = parseInt(this.opts.defaultDirMode, 10); + } + if (!mode) { + mode = 493; + } + } else { + if (this.opts.defaultFileMode) { + mode = parseInt(this.opts.defaultFileMode, 10); + } + if (!mode) { + mode = 420; + } + } + } + return mode; + } + }; + module.exports = async function(zipPath, opts) { + debug5("creating target directory", opts.dir); + if (!path10.isAbsolute(opts.dir)) { + throw new Error("Target directory is expected to be absolute"); + } + await fs6.mkdir(opts.dir, { recursive: true }); + opts.dir = await fs6.realpath(opts.dir); + return new Extractor(zipPath, opts).extract(); + }; + } +}); + +// ../testeranto/node_modules/queue-tick/queue-microtask.js +var require_queue_microtask = __commonJS({ + "../testeranto/node_modules/queue-tick/queue-microtask.js"(exports, module) { + init_cjs_shim(); + module.exports = typeof queueMicrotask === "function" ? queueMicrotask : (fn) => Promise.resolve().then(fn); + } +}); + +// ../testeranto/node_modules/queue-tick/process-next-tick.js +var require_process_next_tick = __commonJS({ + "../testeranto/node_modules/queue-tick/process-next-tick.js"(exports, module) { + init_cjs_shim(); + module.exports = typeof process !== "undefined" && typeof process.nextTick === "function" ? process.nextTick.bind(process) : require_queue_microtask(); + } +}); + +// ../testeranto/node_modules/fast-fifo/fixed-size.js +var require_fixed_size = __commonJS({ + "../testeranto/node_modules/fast-fifo/fixed-size.js"(exports, module) { + init_cjs_shim(); + module.exports = class FixedFIFO { + constructor(hwm) { + if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) + throw new Error("Max size for a FixedFIFO should be a power of two"); + this.buffer = new Array(hwm); + this.mask = hwm - 1; + this.top = 0; + this.btm = 0; + this.next = null; + } + clear() { + this.top = this.btm = 0; + this.next = null; + this.buffer.fill(void 0); + } + push(data) { + if (this.buffer[this.top] !== void 0) + return false; + this.buffer[this.top] = data; + this.top = this.top + 1 & this.mask; + return true; + } + shift() { + const last = this.buffer[this.btm]; + if (last === void 0) + return void 0; + this.buffer[this.btm] = void 0; + this.btm = this.btm + 1 & this.mask; + return last; + } + peek() { + return this.buffer[this.btm]; + } + isEmpty() { + return this.buffer[this.btm] === void 0; + } + }; + } +}); + +// ../testeranto/node_modules/fast-fifo/index.js +var require_fast_fifo = __commonJS({ + "../testeranto/node_modules/fast-fifo/index.js"(exports, module) { + init_cjs_shim(); + var FixedFIFO = require_fixed_size(); + module.exports = class FastFIFO { + constructor(hwm) { + this.hwm = hwm || 16; + this.head = new FixedFIFO(this.hwm); + this.tail = this.head; + this.length = 0; + } + clear() { + this.head = this.tail; + this.head.clear(); + this.length = 0; + } + push(val) { + this.length++; + if (!this.head.push(val)) { + const prev = this.head; + this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length); + this.head.push(val); + } + } + shift() { + if (this.length !== 0) + this.length--; + const val = this.tail.shift(); + if (val === void 0 && this.tail.next) { + const next = this.tail.next; + this.tail.next = null; + this.tail = next; + return this.tail.shift(); + } + return val; + } + peek() { + const val = this.tail.peek(); + if (val === void 0 && this.tail.next) + return this.tail.next.peek(); + return val; + } + isEmpty() { + return this.length === 0; + } + }; + } +}); + +// ../testeranto/node_modules/text-decoder/lib/pass-through-decoder.js +var require_pass_through_decoder = __commonJS({ + "../testeranto/node_modules/text-decoder/lib/pass-through-decoder.js"(exports, module) { + init_cjs_shim(); + module.exports = class PassThroughDecoder { + constructor(encoding) { + this.encoding = encoding; + } + get remaining() { + return 0; + } + decode(tail) { + return tail.toString(this.encoding); + } + flush() { + return ""; + } + }; + } +}); + +// ../testeranto/node_modules/text-decoder/lib/utf8-decoder.js +var require_utf8_decoder = __commonJS({ + "../testeranto/node_modules/text-decoder/lib/utf8-decoder.js"(exports, module) { + init_cjs_shim(); + module.exports = class UTF8Decoder { + constructor() { + this.codePoint = 0; + this.bytesSeen = 0; + this.bytesNeeded = 0; + this.lowerBoundary = 128; + this.upperBoundary = 191; + } + get remaining() { + return this.bytesSeen; + } + decode(data) { + if (this.bytesNeeded === 0) { + let isBoundary = true; + for (let i = Math.max(0, data.byteLength - 4), n = data.byteLength; i < n && isBoundary; i++) { + isBoundary = data[i] <= 127; + } + if (isBoundary) + return data.toString(); + } + let result = ""; + for (let i = 0, n = data.byteLength; i < n; i++) { + const byte = data[i]; + if (this.bytesNeeded === 0) { + if (byte <= 127) { + result += String.fromCharCode(byte); + } else { + this.bytesSeen = 1; + if (byte >= 194 && byte <= 223) { + this.bytesNeeded = 2; + this.codePoint = byte & 31; + } else if (byte >= 224 && byte <= 239) { + if (byte === 224) + this.lowerBoundary = 160; + else if (byte === 237) + this.upperBoundary = 159; + this.bytesNeeded = 3; + this.codePoint = byte & 15; + } else if (byte >= 240 && byte <= 244) { + if (byte === 240) + this.lowerBoundary = 144; + if (byte === 244) + this.upperBoundary = 143; + this.bytesNeeded = 4; + this.codePoint = byte & 7; + } else { + result += "\uFFFD"; + } + } + continue; + } + if (byte < this.lowerBoundary || byte > this.upperBoundary) { + this.codePoint = 0; + this.bytesNeeded = 0; + this.bytesSeen = 0; + this.lowerBoundary = 128; + this.upperBoundary = 191; + result += "\uFFFD"; + continue; + } + this.lowerBoundary = 128; + this.upperBoundary = 191; + this.codePoint = this.codePoint << 6 | byte & 63; + this.bytesSeen++; + if (this.bytesSeen !== this.bytesNeeded) + continue; + result += String.fromCodePoint(this.codePoint); + this.codePoint = 0; + this.bytesNeeded = 0; + this.bytesSeen = 0; + } + return result; + } + flush() { + const result = this.bytesNeeded > 0 ? "\uFFFD" : ""; + this.codePoint = 0; + this.bytesNeeded = 0; + this.bytesSeen = 0; + this.lowerBoundary = 128; + this.upperBoundary = 191; + return result; + } + }; + } +}); + +// ../testeranto/node_modules/text-decoder/index.js +var require_text_decoder = __commonJS({ + "../testeranto/node_modules/text-decoder/index.js"(exports, module) { + init_cjs_shim(); + var PassThroughDecoder = require_pass_through_decoder(); + var UTF8Decoder = require_utf8_decoder(); + module.exports = class TextDecoder { + constructor(encoding = "utf8") { + this.encoding = normalizeEncoding(encoding); + switch (this.encoding) { + case "utf8": + this.decoder = new UTF8Decoder(); + break; + case "utf16le": + case "base64": + throw new Error("Unsupported encoding: " + this.encoding); + default: + this.decoder = new PassThroughDecoder(this.encoding); + } + } + get remaining() { + return this.decoder.remaining; + } + push(data) { + if (typeof data === "string") + return data; + return this.decoder.decode(data); + } + // For Node.js compatibility + write(data) { + return this.push(data); + } + end(data) { + let result = ""; + if (data) + result = this.push(data); + result += this.decoder.flush(); + return result; + } + }; + function normalizeEncoding(encoding) { + encoding = encoding.toLowerCase(); + switch (encoding) { + case "utf8": + case "utf-8": + return "utf8"; + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return "utf16le"; + case "latin1": + case "binary": + return "latin1"; + case "base64": + case "ascii": + case "hex": + return encoding; + default: + throw new Error("Unknown encoding: " + encoding); + } + } + } +}); + +// ../testeranto/node_modules/streamx/index.js +var require_streamx = __commonJS({ + "../testeranto/node_modules/streamx/index.js"(exports, module) { + init_cjs_shim(); + var { EventEmitter: EventEmitter2 } = __require("events"); + var STREAM_DESTROYED = new Error("Stream was destroyed"); + var PREMATURE_CLOSE = new Error("Premature close"); + var queueTick = require_process_next_tick(); + var FIFO = require_fast_fifo(); + var TextDecoder2 = require_text_decoder(); + var MAX = (1 << 29) - 1; + var OPENING = 1; + var PREDESTROYING = 2; + var DESTROYING = 4; + var DESTROYED = 8; + var NOT_OPENING = MAX ^ OPENING; + var NOT_PREDESTROYING = MAX ^ PREDESTROYING; + var READ_ACTIVE = 1 << 4; + var READ_UPDATING = 2 << 4; + var READ_PRIMARY = 4 << 4; + var READ_QUEUED = 8 << 4; + var READ_RESUMED = 16 << 4; + var READ_PIPE_DRAINED = 32 << 4; + var READ_ENDING = 64 << 4; + var READ_EMIT_DATA = 128 << 4; + var READ_EMIT_READABLE = 256 << 4; + var READ_EMITTED_READABLE = 512 << 4; + var READ_DONE = 1024 << 4; + var READ_NEXT_TICK = 2048 << 4; + var READ_NEEDS_PUSH = 4096 << 4; + var READ_READ_AHEAD = 8192 << 4; + var READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED; + var READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH; + var READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE; + var READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED; + var READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD; + var READ_NOT_ACTIVE = MAX ^ READ_ACTIVE; + var READ_NON_PRIMARY = MAX ^ READ_PRIMARY; + var READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH); + var READ_PUSHED = MAX ^ READ_NEEDS_PUSH; + var READ_PAUSED = MAX ^ READ_RESUMED; + var READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE); + var READ_NOT_ENDING = MAX ^ READ_ENDING; + var READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING; + var READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK; + var READ_NOT_UPDATING = MAX ^ READ_UPDATING; + var READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD; + var READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD; + var WRITE_ACTIVE = 1 << 18; + var WRITE_UPDATING = 2 << 18; + var WRITE_PRIMARY = 4 << 18; + var WRITE_QUEUED = 8 << 18; + var WRITE_UNDRAINED = 16 << 18; + var WRITE_DONE = 32 << 18; + var WRITE_EMIT_DRAIN = 64 << 18; + var WRITE_NEXT_TICK = 128 << 18; + var WRITE_WRITING = 256 << 18; + var WRITE_FINISHING = 512 << 18; + var WRITE_CORKED = 1024 << 18; + var WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING); + var WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY; + var WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING); + var WRITE_DRAINED = MAX ^ WRITE_UNDRAINED; + var WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED; + var WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK; + var WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING; + var WRITE_NOT_CORKED = MAX ^ WRITE_CORKED; + var ACTIVE = READ_ACTIVE | WRITE_ACTIVE; + var NOT_ACTIVE = MAX ^ ACTIVE; + var DONE = READ_DONE | WRITE_DONE; + var DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING; + var OPEN_STATUS = DESTROY_STATUS | OPENING; + var AUTO_DESTROY = DESTROY_STATUS | DONE; + var NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY; + var ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK; + var TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE; + var IS_OPENING = OPEN_STATUS | TICKING; + var READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE; + var READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED; + var READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED; + var READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE; + var SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD; + var READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE; + var READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY; + var WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE; + var WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED; + var WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE; + var WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE; + var WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED; + var WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE; + var WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING; + var WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE; + var WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE; + var WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY; + var WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS; + var asyncIterator = Symbol.asyncIterator || Symbol("asyncIterator"); + var WritableState = class { + constructor(stream, { highWaterMark = 16384, map: map2 = null, mapWritable, byteLength, byteLengthWritable } = {}) { + this.stream = stream; + this.queue = new FIFO(); + this.highWaterMark = highWaterMark; + this.buffered = 0; + this.error = null; + this.pipeline = null; + this.drains = null; + this.byteLength = byteLengthWritable || byteLength || defaultByteLength; + this.map = mapWritable || map2; + this.afterWrite = afterWrite.bind(this); + this.afterUpdateNextTick = updateWriteNT.bind(this); + } + get ended() { + return (this.stream._duplexState & WRITE_DONE) !== 0; + } + push(data) { + if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) + return false; + if (this.map !== null) + data = this.map(data); + this.buffered += this.byteLength(data); + this.queue.push(data); + if (this.buffered < this.highWaterMark) { + this.stream._duplexState |= WRITE_QUEUED; + return true; + } + this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED; + return false; + } + shift() { + const data = this.queue.shift(); + this.buffered -= this.byteLength(data); + if (this.buffered === 0) + this.stream._duplexState &= WRITE_NOT_QUEUED; + return data; + } + end(data) { + if (typeof data === "function") + this.stream.once("finish", data); + else if (data !== void 0 && data !== null) + this.push(data); + this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY; + } + autoBatch(data, cb) { + const buffer = []; + const stream = this.stream; + buffer.push(data); + while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) { + buffer.push(stream._writableState.shift()); + } + if ((stream._duplexState & OPEN_STATUS) !== 0) + return cb(null); + stream._writev(buffer, cb); + } + update() { + const stream = this.stream; + stream._duplexState |= WRITE_UPDATING; + do { + while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) { + const data = this.shift(); + stream._duplexState |= WRITE_ACTIVE_AND_WRITING; + stream._write(data, this.afterWrite); + } + if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) + this.updateNonPrimary(); + } while (this.continueUpdate() === true); + stream._duplexState &= WRITE_NOT_UPDATING; + } + updateNonPrimary() { + const stream = this.stream; + if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) { + stream._duplexState = stream._duplexState | WRITE_ACTIVE; + stream._final(afterFinal.bind(this)); + return; + } + if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { + if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { + stream._duplexState |= ACTIVE; + stream._destroy(afterDestroy.bind(this)); + } + return; + } + if ((stream._duplexState & IS_OPENING) === OPENING) { + stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING; + stream._open(afterOpen.bind(this)); + } + } + continueUpdate() { + if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) + return false; + this.stream._duplexState &= WRITE_NOT_NEXT_TICK; + return true; + } + updateCallback() { + if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) + this.update(); + else + this.updateNextTick(); + } + updateNextTick() { + if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) + return; + this.stream._duplexState |= WRITE_NEXT_TICK; + if ((this.stream._duplexState & WRITE_UPDATING) === 0) + queueTick(this.afterUpdateNextTick); + } + }; + var ReadableState = class { + constructor(stream, { highWaterMark = 16384, map: map2 = null, mapReadable, byteLength, byteLengthReadable } = {}) { + this.stream = stream; + this.queue = new FIFO(); + this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark; + this.buffered = 0; + this.readAhead = highWaterMark > 0; + this.error = null; + this.pipeline = null; + this.byteLength = byteLengthReadable || byteLength || defaultByteLength; + this.map = mapReadable || map2; + this.pipeTo = null; + this.afterRead = afterRead.bind(this); + this.afterUpdateNextTick = updateReadNT.bind(this); + } + get ended() { + return (this.stream._duplexState & READ_DONE) !== 0; + } + pipe(pipeTo, cb) { + if (this.pipeTo !== null) + throw new Error("Can only pipe to one destination"); + if (typeof cb !== "function") + cb = null; + this.stream._duplexState |= READ_PIPE_DRAINED; + this.pipeTo = pipeTo; + this.pipeline = new Pipeline(this.stream, pipeTo, cb); + if (cb) + this.stream.on("error", noop); + if (isStreamx(pipeTo)) { + pipeTo._writableState.pipeline = this.pipeline; + if (cb) + pipeTo.on("error", noop); + pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline)); + } else { + const onerror = this.pipeline.done.bind(this.pipeline, pipeTo); + const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null); + pipeTo.on("error", onerror); + pipeTo.on("close", onclose); + pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline)); + } + pipeTo.on("drain", afterDrain.bind(this)); + this.stream.emit("piping", pipeTo); + pipeTo.emit("pipe", this.stream); + } + push(data) { + const stream = this.stream; + if (data === null) { + this.highWaterMark = 0; + stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED; + return false; + } + if (this.map !== null) { + data = this.map(data); + if (data === null) { + stream._duplexState &= READ_PUSHED; + return this.buffered < this.highWaterMark; + } + } + this.buffered += this.byteLength(data); + this.queue.push(data); + stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED; + return this.buffered < this.highWaterMark; + } + shift() { + const data = this.queue.shift(); + this.buffered -= this.byteLength(data); + if (this.buffered === 0) + this.stream._duplexState &= READ_NOT_QUEUED; + return data; + } + unshift(data) { + const pending = [this.map !== null ? this.map(data) : data]; + while (this.buffered > 0) + pending.push(this.shift()); + for (let i = 0; i < pending.length - 1; i++) { + const data2 = pending[i]; + this.buffered += this.byteLength(data2); + this.queue.push(data2); + } + this.push(pending[pending.length - 1]); + } + read() { + const stream = this.stream; + if ((stream._duplexState & READ_STATUS) === READ_QUEUED) { + const data = this.shift(); + if (this.pipeTo !== null && this.pipeTo.write(data) === false) + stream._duplexState &= READ_PIPE_NOT_DRAINED; + if ((stream._duplexState & READ_EMIT_DATA) !== 0) + stream.emit("data", data); + return data; + } + if (this.readAhead === false) { + stream._duplexState |= READ_READ_AHEAD; + this.updateNextTick(); + } + return null; + } + drain() { + const stream = this.stream; + while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) { + const data = this.shift(); + if (this.pipeTo !== null && this.pipeTo.write(data) === false) + stream._duplexState &= READ_PIPE_NOT_DRAINED; + if ((stream._duplexState & READ_EMIT_DATA) !== 0) + stream.emit("data", data); + } + } + update() { + const stream = this.stream; + stream._duplexState |= READ_UPDATING; + do { + this.drain(); + while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD) { + stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH; + stream._read(this.afterRead); + this.drain(); + } + if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) { + stream._duplexState |= READ_EMITTED_READABLE; + stream.emit("readable"); + } + if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) + this.updateNonPrimary(); + } while (this.continueUpdate() === true); + stream._duplexState &= READ_NOT_UPDATING; + } + updateNonPrimary() { + const stream = this.stream; + if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) { + stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING; + stream.emit("end"); + if ((stream._duplexState & AUTO_DESTROY) === DONE) + stream._duplexState |= DESTROYING; + if (this.pipeTo !== null) + this.pipeTo.end(); + } + if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { + if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { + stream._duplexState |= ACTIVE; + stream._destroy(afterDestroy.bind(this)); + } + return; + } + if ((stream._duplexState & IS_OPENING) === OPENING) { + stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING; + stream._open(afterOpen.bind(this)); + } + } + continueUpdate() { + if ((this.stream._duplexState & READ_NEXT_TICK) === 0) + return false; + this.stream._duplexState &= READ_NOT_NEXT_TICK; + return true; + } + updateCallback() { + if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) + this.update(); + else + this.updateNextTick(); + } + updateNextTick() { + if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) + return; + this.stream._duplexState |= READ_NEXT_TICK; + if ((this.stream._duplexState & READ_UPDATING) === 0) + queueTick(this.afterUpdateNextTick); + } + }; + var TransformState = class { + constructor(stream) { + this.data = null; + this.afterTransform = afterTransform.bind(stream); + this.afterFinal = null; + } + }; + var Pipeline = class { + constructor(src, dst, cb) { + this.from = src; + this.to = dst; + this.afterPipe = cb; + this.error = null; + this.pipeToFinished = false; + } + finished() { + this.pipeToFinished = true; + } + done(stream, err) { + if (err) + this.error = err; + if (stream === this.to) { + this.to = null; + if (this.from !== null) { + if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) { + this.from.destroy(this.error || new Error("Writable stream closed prematurely")); + } + return; + } + } + if (stream === this.from) { + this.from = null; + if (this.to !== null) { + if ((stream._duplexState & READ_DONE) === 0) { + this.to.destroy(this.error || new Error("Readable stream closed before ending")); + } + return; + } + } + if (this.afterPipe !== null) + this.afterPipe(this.error); + this.to = this.from = this.afterPipe = null; + } + }; + function afterDrain() { + this.stream._duplexState |= READ_PIPE_DRAINED; + this.updateCallback(); + } + function afterFinal(err) { + const stream = this.stream; + if (err) + stream.destroy(err); + if ((stream._duplexState & DESTROY_STATUS) === 0) { + stream._duplexState |= WRITE_DONE; + stream.emit("finish"); + } + if ((stream._duplexState & AUTO_DESTROY) === DONE) { + stream._duplexState |= DESTROYING; + } + stream._duplexState &= WRITE_NOT_FINISHING; + if ((stream._duplexState & WRITE_UPDATING) === 0) + this.update(); + else + this.updateNextTick(); + } + function afterDestroy(err) { + const stream = this.stream; + if (!err && this.error !== STREAM_DESTROYED) + err = this.error; + if (err) + stream.emit("error", err); + stream._duplexState |= DESTROYED; + stream.emit("close"); + const rs = stream._readableState; + const ws = stream._writableState; + if (rs !== null && rs.pipeline !== null) + rs.pipeline.done(stream, err); + if (ws !== null) { + while (ws.drains !== null && ws.drains.length > 0) + ws.drains.shift().resolve(false); + if (ws.pipeline !== null) + ws.pipeline.done(stream, err); + } + } + function afterWrite(err) { + const stream = this.stream; + if (err) + stream.destroy(err); + stream._duplexState &= WRITE_NOT_ACTIVE; + if (this.drains !== null) + tickDrains(this.drains); + if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) { + stream._duplexState &= WRITE_DRAINED; + if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) { + stream.emit("drain"); + } + } + this.updateCallback(); + } + function afterRead(err) { + if (err) + this.stream.destroy(err); + this.stream._duplexState &= READ_NOT_ACTIVE; + if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0) + this.stream._duplexState &= READ_NO_READ_AHEAD; + this.updateCallback(); + } + function updateReadNT() { + if ((this.stream._duplexState & READ_UPDATING) === 0) { + this.stream._duplexState &= READ_NOT_NEXT_TICK; + this.update(); + } + } + function updateWriteNT() { + if ((this.stream._duplexState & WRITE_UPDATING) === 0) { + this.stream._duplexState &= WRITE_NOT_NEXT_TICK; + this.update(); + } + } + function tickDrains(drains) { + for (let i = 0; i < drains.length; i++) { + if (--drains[i].writes === 0) { + drains.shift().resolve(true); + i--; + } + } + } + function afterOpen(err) { + const stream = this.stream; + if (err) + stream.destroy(err); + if ((stream._duplexState & DESTROYING) === 0) { + if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) + stream._duplexState |= READ_PRIMARY; + if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) + stream._duplexState |= WRITE_PRIMARY; + stream.emit("open"); + } + stream._duplexState &= NOT_ACTIVE; + if (stream._writableState !== null) { + stream._writableState.updateCallback(); + } + if (stream._readableState !== null) { + stream._readableState.updateCallback(); + } + } + function afterTransform(err, data) { + if (data !== void 0 && data !== null) + this.push(data); + this._writableState.afterWrite(err); + } + function newListener(name) { + if (this._readableState !== null) { + if (name === "data") { + this._duplexState |= READ_EMIT_DATA | READ_RESUMED_READ_AHEAD; + this._readableState.updateNextTick(); + } + if (name === "readable") { + this._duplexState |= READ_EMIT_READABLE; + this._readableState.updateNextTick(); + } + } + if (this._writableState !== null) { + if (name === "drain") { + this._duplexState |= WRITE_EMIT_DRAIN; + this._writableState.updateNextTick(); + } + } + } + var Stream = class extends EventEmitter2 { + constructor(opts) { + super(); + this._duplexState = 0; + this._readableState = null; + this._writableState = null; + if (opts) { + if (opts.open) + this._open = opts.open; + if (opts.destroy) + this._destroy = opts.destroy; + if (opts.predestroy) + this._predestroy = opts.predestroy; + if (opts.signal) { + opts.signal.addEventListener("abort", abort.bind(this)); + } + } + this.on("newListener", newListener); + } + _open(cb) { + cb(null); + } + _destroy(cb) { + cb(null); + } + _predestroy() { + } + get readable() { + return this._readableState !== null ? true : void 0; + } + get writable() { + return this._writableState !== null ? true : void 0; + } + get destroyed() { + return (this._duplexState & DESTROYED) !== 0; + } + get destroying() { + return (this._duplexState & DESTROY_STATUS) !== 0; + } + destroy(err) { + if ((this._duplexState & DESTROY_STATUS) === 0) { + if (!err) + err = STREAM_DESTROYED; + this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY; + if (this._readableState !== null) { + this._readableState.highWaterMark = 0; + this._readableState.error = err; + } + if (this._writableState !== null) { + this._writableState.highWaterMark = 0; + this._writableState.error = err; + } + this._duplexState |= PREDESTROYING; + this._predestroy(); + this._duplexState &= NOT_PREDESTROYING; + if (this._readableState !== null) + this._readableState.updateNextTick(); + if (this._writableState !== null) + this._writableState.updateNextTick(); + } + } + }; + var Readable = class extends Stream { + constructor(opts) { + super(opts); + this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD; + this._readableState = new ReadableState(this, opts); + if (opts) { + if (this._readableState.readAhead === false) + this._duplexState &= READ_NO_READ_AHEAD; + if (opts.read) + this._read = opts.read; + if (opts.eagerOpen) + this._readableState.updateNextTick(); + if (opts.encoding) + this.setEncoding(opts.encoding); + } + } + setEncoding(encoding) { + const dec = new TextDecoder2(encoding); + const map2 = this._readableState.map || echo; + this._readableState.map = mapOrSkip; + return this; + function mapOrSkip(data) { + const next = dec.push(data); + return next === "" && (data.byteLength !== 0 || dec.remaining > 0) ? null : map2(next); + } + } + _read(cb) { + cb(null); + } + pipe(dest, cb) { + this._readableState.updateNextTick(); + this._readableState.pipe(dest, cb); + return dest; + } + read() { + this._readableState.updateNextTick(); + return this._readableState.read(); + } + push(data) { + this._readableState.updateNextTick(); + return this._readableState.push(data); + } + unshift(data) { + this._readableState.updateNextTick(); + return this._readableState.unshift(data); + } + resume() { + this._duplexState |= READ_RESUMED_READ_AHEAD; + this._readableState.updateNextTick(); + return this; + } + pause() { + this._duplexState &= this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED; + return this; + } + static _fromAsyncIterator(ite, opts) { + let destroy; + const rs = new Readable({ + ...opts, + read(cb) { + ite.next().then(push).then(cb.bind(null, null)).catch(cb); + }, + predestroy() { + destroy = ite.return(); + }, + destroy(cb) { + if (!destroy) + return cb(null); + destroy.then(cb.bind(null, null)).catch(cb); + } + }); + return rs; + function push(data) { + if (data.done) + rs.push(null); + else + rs.push(data.value); + } + } + static from(data, opts) { + if (isReadStreamx(data)) + return data; + if (data[asyncIterator]) + return this._fromAsyncIterator(data[asyncIterator](), opts); + if (!Array.isArray(data)) + data = data === void 0 ? [] : [data]; + let i = 0; + return new Readable({ + ...opts, + read(cb) { + this.push(i === data.length ? null : data[i++]); + cb(null); + } + }); + } + static isBackpressured(rs) { + return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark; + } + static isPaused(rs) { + return (rs._duplexState & READ_RESUMED) === 0; + } + [asyncIterator]() { + const stream = this; + let error = null; + let promiseResolve = null; + let promiseReject = null; + this.on("error", (err) => { + error = err; + }); + this.on("readable", onreadable); + this.on("close", onclose); + return { + [asyncIterator]() { + return this; + }, + next() { + return new Promise(function(resolve5, reject) { + promiseResolve = resolve5; + promiseReject = reject; + const data = stream.read(); + if (data !== null) + ondata(data); + else if ((stream._duplexState & DESTROYED) !== 0) + ondata(null); + }); + }, + return() { + return destroy(null); + }, + throw(err) { + return destroy(err); + } + }; + function onreadable() { + if (promiseResolve !== null) + ondata(stream.read()); + } + function onclose() { + if (promiseResolve !== null) + ondata(null); + } + function ondata(data) { + if (promiseReject === null) + return; + if (error) + promiseReject(error); + else if (data === null && (stream._duplexState & READ_DONE) === 0) + promiseReject(STREAM_DESTROYED); + else + promiseResolve({ value: data, done: data === null }); + promiseReject = promiseResolve = null; + } + function destroy(err) { + stream.destroy(err); + return new Promise((resolve5, reject) => { + if (stream._duplexState & DESTROYED) + return resolve5({ value: void 0, done: true }); + stream.once("close", function() { + if (err) + reject(err); + else + resolve5({ value: void 0, done: true }); + }); + }); + } + } + }; + var Writable = class extends Stream { + constructor(opts) { + super(opts); + this._duplexState |= OPENING | READ_DONE; + this._writableState = new WritableState(this, opts); + if (opts) { + if (opts.writev) + this._writev = opts.writev; + if (opts.write) + this._write = opts.write; + if (opts.final) + this._final = opts.final; + if (opts.eagerOpen) + this._writableState.updateNextTick(); + } + } + cork() { + this._duplexState |= WRITE_CORKED; + } + uncork() { + this._duplexState &= WRITE_NOT_CORKED; + this._writableState.updateNextTick(); + } + _writev(batch, cb) { + cb(null); + } + _write(data, cb) { + this._writableState.autoBatch(data, cb); + } + _final(cb) { + cb(null); + } + static isBackpressured(ws) { + return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0; + } + static drained(ws) { + if (ws.destroyed) + return Promise.resolve(false); + const state = ws._writableState; + const pending = isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length; + const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0); + if (writes === 0) + return Promise.resolve(true); + if (state.drains === null) + state.drains = []; + return new Promise((resolve5) => { + state.drains.push({ writes, resolve: resolve5 }); + }); + } + write(data) { + this._writableState.updateNextTick(); + return this._writableState.push(data); + } + end(data) { + this._writableState.updateNextTick(); + this._writableState.end(data); + return this; + } + }; + var Duplex = class extends Readable { + // and Writable + constructor(opts) { + super(opts); + this._duplexState = OPENING | this._duplexState & READ_READ_AHEAD; + this._writableState = new WritableState(this, opts); + if (opts) { + if (opts.writev) + this._writev = opts.writev; + if (opts.write) + this._write = opts.write; + if (opts.final) + this._final = opts.final; + } + } + cork() { + this._duplexState |= WRITE_CORKED; + } + uncork() { + this._duplexState &= WRITE_NOT_CORKED; + this._writableState.updateNextTick(); + } + _writev(batch, cb) { + cb(null); + } + _write(data, cb) { + this._writableState.autoBatch(data, cb); + } + _final(cb) { + cb(null); + } + write(data) { + this._writableState.updateNextTick(); + return this._writableState.push(data); + } + end(data) { + this._writableState.updateNextTick(); + this._writableState.end(data); + return this; + } + }; + var Transform = class extends Duplex { + constructor(opts) { + super(opts); + this._transformState = new TransformState(this); + if (opts) { + if (opts.transform) + this._transform = opts.transform; + if (opts.flush) + this._flush = opts.flush; + } + } + _write(data, cb) { + if (this._readableState.buffered >= this._readableState.highWaterMark) { + this._transformState.data = data; + } else { + this._transform(data, this._transformState.afterTransform); + } + } + _read(cb) { + if (this._transformState.data !== null) { + const data = this._transformState.data; + this._transformState.data = null; + cb(null); + this._transform(data, this._transformState.afterTransform); + } else { + cb(null); + } + } + destroy(err) { + super.destroy(err); + if (this._transformState.data !== null) { + this._transformState.data = null; + this._transformState.afterTransform(); + } + } + _transform(data, cb) { + cb(null, data); + } + _flush(cb) { + cb(null); + } + _final(cb) { + this._transformState.afterFinal = cb; + this._flush(transformAfterFlush.bind(this)); + } + }; + var PassThrough2 = class extends Transform { + }; + function transformAfterFlush(err, data) { + const cb = this._transformState.afterFinal; + if (err) + return cb(err); + if (data !== null && data !== void 0) + this.push(data); + this.push(null); + cb(null); + } + function pipelinePromise(...streams) { + return new Promise((resolve5, reject) => { + return pipeline(...streams, (err) => { + if (err) + return reject(err); + resolve5(); + }); + }); + } + function pipeline(stream, ...streams) { + const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams]; + const done = all.length && typeof all[all.length - 1] === "function" ? all.pop() : null; + if (all.length < 2) + throw new Error("Pipeline requires at least 2 streams"); + let src = all[0]; + let dest = null; + let error = null; + for (let i = 1; i < all.length; i++) { + dest = all[i]; + if (isStreamx(src)) { + src.pipe(dest, onerror); + } else { + errorHandle(src, true, i > 1, onerror); + src.pipe(dest); + } + src = dest; + } + if (done) { + let fin = false; + const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy); + dest.on("error", (err) => { + if (error === null) + error = err; + }); + dest.on("finish", () => { + fin = true; + if (!autoDestroy) + done(error); + }); + if (autoDestroy) { + dest.on("close", () => done(error || (fin ? null : PREMATURE_CLOSE))); + } + } + return dest; + function errorHandle(s, rd, wr, onerror2) { + s.on("error", onerror2); + s.on("close", onclose); + function onclose() { + if (rd && s._readableState && !s._readableState.ended) + return onerror2(PREMATURE_CLOSE); + if (wr && s._writableState && !s._writableState.ended) + return onerror2(PREMATURE_CLOSE); + } + } + function onerror(err) { + if (!err || error) + return; + error = err; + for (const s of all) { + s.destroy(err); + } + } + } + function echo(s) { + return s; + } + function isStream(stream) { + return !!stream._readableState || !!stream._writableState; + } + function isStreamx(stream) { + return typeof stream._duplexState === "number" && isStream(stream); + } + function isEnded(stream) { + return !!stream._readableState && stream._readableState.ended; + } + function isFinished(stream) { + return !!stream._writableState && stream._writableState.ended; + } + function getStreamError(stream, opts = {}) { + const err = stream._readableState && stream._readableState.error || stream._writableState && stream._writableState.error; + return !opts.all && err === STREAM_DESTROYED ? null : err; + } + function isReadStreamx(stream) { + return isStreamx(stream) && stream.readable; + } + function isTypedArray(data) { + return typeof data === "object" && data !== null && typeof data.byteLength === "number"; + } + function defaultByteLength(data) { + return isTypedArray(data) ? data.byteLength : 1024; + } + function noop() { + } + function abort() { + this.destroy(new Error("Stream aborted.")); + } + function isWritev(s) { + return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev; + } + module.exports = { + pipeline, + pipelinePromise, + isStream, + isStreamx, + isEnded, + isFinished, + getStreamError, + Stream, + Writable, + Readable, + Duplex, + Transform, + // Export PassThrough for compatibility with Node.js core's stream module + PassThrough: PassThrough2 + }; + } +}); + +// ../testeranto/node_modules/b4a/index.js +var require_b4a = __commonJS({ + "../testeranto/node_modules/b4a/index.js"(exports, module) { + init_cjs_shim(); + function isBuffer(value) { + return Buffer.isBuffer(value) || value instanceof Uint8Array; + } + function isEncoding(encoding) { + return Buffer.isEncoding(encoding); + } + function alloc(size, fill2, encoding) { + return Buffer.alloc(size, fill2, encoding); + } + function allocUnsafe(size) { + return Buffer.allocUnsafe(size); + } + function allocUnsafeSlow(size) { + return Buffer.allocUnsafeSlow(size); + } + function byteLength(string, encoding) { + return Buffer.byteLength(string, encoding); + } + function compare(a, b) { + return Buffer.compare(a, b); + } + function concat(buffers, totalLength) { + return Buffer.concat(buffers, totalLength); + } + function copy(source, target, targetStart, start, end) { + return toBuffer(source).copy(target, targetStart, start, end); + } + function equals(a, b) { + return toBuffer(a).equals(b); + } + function fill(buffer, value, offset, end, encoding) { + return toBuffer(buffer).fill(value, offset, end, encoding); + } + function from2(value, encodingOrOffset, length) { + return Buffer.from(value, encodingOrOffset, length); + } + function includes(buffer, value, byteOffset, encoding) { + return toBuffer(buffer).includes(value, byteOffset, encoding); + } + function indexOf(buffer, value, byfeOffset, encoding) { + return toBuffer(buffer).indexOf(value, byfeOffset, encoding); + } + function lastIndexOf(buffer, value, byteOffset, encoding) { + return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding); + } + function swap16(buffer) { + return toBuffer(buffer).swap16(); + } + function swap32(buffer) { + return toBuffer(buffer).swap32(); + } + function swap64(buffer) { + return toBuffer(buffer).swap64(); + } + function toBuffer(buffer) { + if (Buffer.isBuffer(buffer)) + return buffer; + return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength); + } + function toString(buffer, encoding, start, end) { + return toBuffer(buffer).toString(encoding, start, end); + } + function write(buffer, string, offset, length, encoding) { + return toBuffer(buffer).write(string, offset, length, encoding); + } + function writeDoubleLE(buffer, value, offset) { + return toBuffer(buffer).writeDoubleLE(value, offset); + } + function writeFloatLE(buffer, value, offset) { + return toBuffer(buffer).writeFloatLE(value, offset); + } + function writeUInt32LE(buffer, value, offset) { + return toBuffer(buffer).writeUInt32LE(value, offset); + } + function writeInt32LE(buffer, value, offset) { + return toBuffer(buffer).writeInt32LE(value, offset); + } + function readDoubleLE(buffer, offset) { + return toBuffer(buffer).readDoubleLE(offset); + } + function readFloatLE(buffer, offset) { + return toBuffer(buffer).readFloatLE(offset); + } + function readUInt32LE(buffer, offset) { + return toBuffer(buffer).readUInt32LE(offset); + } + function readInt32LE(buffer, offset) { + return toBuffer(buffer).readInt32LE(offset); + } + function writeDoubleBE(buffer, value, offset) { + return toBuffer(buffer).writeDoubleBE(value, offset); + } + function writeFloatBE(buffer, value, offset) { + return toBuffer(buffer).writeFloatBE(value, offset); + } + function writeUInt32BE(buffer, value, offset) { + return toBuffer(buffer).writeUInt32BE(value, offset); + } + function writeInt32BE(buffer, value, offset) { + return toBuffer(buffer).writeInt32BE(value, offset); + } + function readDoubleBE(buffer, offset) { + return toBuffer(buffer).readDoubleBE(offset); + } + function readFloatBE(buffer, offset) { + return toBuffer(buffer).readFloatBE(offset); + } + function readUInt32BE(buffer, offset) { + return toBuffer(buffer).readUInt32BE(offset); + } + function readInt32BE(buffer, offset) { + return toBuffer(buffer).readInt32BE(offset); + } + module.exports = { + isBuffer, + isEncoding, + alloc, + allocUnsafe, + allocUnsafeSlow, + byteLength, + compare, + concat, + copy, + equals, + fill, + from: from2, + includes, + indexOf, + lastIndexOf, + swap16, + swap32, + swap64, + toBuffer, + toString, + write, + writeDoubleLE, + writeFloatLE, + writeUInt32LE, + writeInt32LE, + readDoubleLE, + readFloatLE, + readUInt32LE, + readInt32LE, + writeDoubleBE, + writeFloatBE, + writeUInt32BE, + writeInt32BE, + readDoubleBE, + readFloatBE, + readUInt32BE, + readInt32BE + }; + } +}); + +// ../testeranto/node_modules/tar-stream/headers.js +var require_headers = __commonJS({ + "../testeranto/node_modules/tar-stream/headers.js"(exports) { + init_cjs_shim(); + var b4a = require_b4a(); + var ZEROS = "0000000000000000000"; + var SEVENS = "7777777777777777777"; + var ZERO_OFFSET = "0".charCodeAt(0); + var USTAR_MAGIC = b4a.from([117, 115, 116, 97, 114, 0]); + var USTAR_VER = b4a.from([ZERO_OFFSET, ZERO_OFFSET]); + var GNU_MAGIC = b4a.from([117, 115, 116, 97, 114, 32]); + var GNU_VER = b4a.from([32, 0]); + var MASK = 4095; + var MAGIC_OFFSET = 257; + var VERSION_OFFSET = 263; + exports.decodeLongPath = function decodeLongPath(buf, encoding) { + return decodeStr(buf, 0, buf.length, encoding); + }; + exports.encodePax = function encodePax(opts) { + let result = ""; + if (opts.name) + result += addLength(" path=" + opts.name + "\n"); + if (opts.linkname) + result += addLength(" linkpath=" + opts.linkname + "\n"); + const pax = opts.pax; + if (pax) { + for (const key in pax) { + result += addLength(" " + key + "=" + pax[key] + "\n"); + } + } + return b4a.from(result); + }; + exports.decodePax = function decodePax(buf) { + const result = {}; + while (buf.length) { + let i = 0; + while (i < buf.length && buf[i] !== 32) + i++; + const len = parseInt(b4a.toString(buf.subarray(0, i)), 10); + if (!len) + return result; + const b = b4a.toString(buf.subarray(i + 1, len - 1)); + const keyIndex = b.indexOf("="); + if (keyIndex === -1) + return result; + result[b.slice(0, keyIndex)] = b.slice(keyIndex + 1); + buf = buf.subarray(len); + } + return result; + }; + exports.encode = function encode(opts) { + const buf = b4a.alloc(512); + let name = opts.name; + let prefix = ""; + if (opts.typeflag === 5 && name[name.length - 1] !== "/") + name += "/"; + if (b4a.byteLength(name) !== name.length) + return null; + while (b4a.byteLength(name) > 100) { + const i = name.indexOf("/"); + if (i === -1) + return null; + prefix += prefix ? "/" + name.slice(0, i) : name.slice(0, i); + name = name.slice(i + 1); + } + if (b4a.byteLength(name) > 100 || b4a.byteLength(prefix) > 155) + return null; + if (opts.linkname && b4a.byteLength(opts.linkname) > 100) + return null; + b4a.write(buf, name); + b4a.write(buf, encodeOct(opts.mode & MASK, 6), 100); + b4a.write(buf, encodeOct(opts.uid, 6), 108); + b4a.write(buf, encodeOct(opts.gid, 6), 116); + encodeSize(opts.size, buf, 124); + b4a.write(buf, encodeOct(opts.mtime.getTime() / 1e3 | 0, 11), 136); + buf[156] = ZERO_OFFSET + toTypeflag(opts.type); + if (opts.linkname) + b4a.write(buf, opts.linkname, 157); + b4a.copy(USTAR_MAGIC, buf, MAGIC_OFFSET); + b4a.copy(USTAR_VER, buf, VERSION_OFFSET); + if (opts.uname) + b4a.write(buf, opts.uname, 265); + if (opts.gname) + b4a.write(buf, opts.gname, 297); + b4a.write(buf, encodeOct(opts.devmajor || 0, 6), 329); + b4a.write(buf, encodeOct(opts.devminor || 0, 6), 337); + if (prefix) + b4a.write(buf, prefix, 345); + b4a.write(buf, encodeOct(cksum(buf), 6), 148); + return buf; + }; + exports.decode = function decode(buf, filenameEncoding, allowUnknownFormat) { + let typeflag = buf[156] === 0 ? 0 : buf[156] - ZERO_OFFSET; + let name = decodeStr(buf, 0, 100, filenameEncoding); + const mode = decodeOct(buf, 100, 8); + const uid = decodeOct(buf, 108, 8); + const gid = decodeOct(buf, 116, 8); + const size = decodeOct(buf, 124, 12); + const mtime = decodeOct(buf, 136, 12); + const type = toType(typeflag); + const linkname = buf[157] === 0 ? null : decodeStr(buf, 157, 100, filenameEncoding); + const uname = decodeStr(buf, 265, 32); + const gname = decodeStr(buf, 297, 32); + const devmajor = decodeOct(buf, 329, 8); + const devminor = decodeOct(buf, 337, 8); + const c = cksum(buf); + if (c === 8 * 32) + return null; + if (c !== decodeOct(buf, 148, 8)) + throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?"); + if (isUSTAR(buf)) { + if (buf[345]) + name = decodeStr(buf, 345, 155, filenameEncoding) + "/" + name; + } else if (isGNU(buf)) { + } else { + if (!allowUnknownFormat) { + throw new Error("Invalid tar header: unknown format."); + } + } + if (typeflag === 0 && name && name[name.length - 1] === "/") + typeflag = 5; + return { + name, + mode, + uid, + gid, + size, + mtime: new Date(1e3 * mtime), + type, + linkname, + uname, + gname, + devmajor, + devminor, + pax: null + }; + }; + function isUSTAR(buf) { + return b4a.equals(USTAR_MAGIC, buf.subarray(MAGIC_OFFSET, MAGIC_OFFSET + 6)); + } + function isGNU(buf) { + return b4a.equals(GNU_MAGIC, buf.subarray(MAGIC_OFFSET, MAGIC_OFFSET + 6)) && b4a.equals(GNU_VER, buf.subarray(VERSION_OFFSET, VERSION_OFFSET + 2)); + } + function clamp(index, len, defaultValue) { + if (typeof index !== "number") + return defaultValue; + index = ~~index; + if (index >= len) + return len; + if (index >= 0) + return index; + index += len; + if (index >= 0) + return index; + return 0; + } + function toType(flag) { + switch (flag) { + case 0: + return "file"; + case 1: + return "link"; + case 2: + return "symlink"; + case 3: + return "character-device"; + case 4: + return "block-device"; + case 5: + return "directory"; + case 6: + return "fifo"; + case 7: + return "contiguous-file"; + case 72: + return "pax-header"; + case 55: + return "pax-global-header"; + case 27: + return "gnu-long-link-path"; + case 28: + case 30: + return "gnu-long-path"; + } + return null; + } + function toTypeflag(flag) { + switch (flag) { + case "file": + return 0; + case "link": + return 1; + case "symlink": + return 2; + case "character-device": + return 3; + case "block-device": + return 4; + case "directory": + return 5; + case "fifo": + return 6; + case "contiguous-file": + return 7; + case "pax-header": + return 72; + } + return 0; + } + function indexOf(block, num, offset, end) { + for (; offset < end; offset++) { + if (block[offset] === num) + return offset; + } + return end; + } + function cksum(block) { + let sum = 8 * 32; + for (let i = 0; i < 148; i++) + sum += block[i]; + for (let j = 156; j < 512; j++) + sum += block[j]; + return sum; + } + function encodeOct(val, n) { + val = val.toString(8); + if (val.length > n) + return SEVENS.slice(0, n) + " "; + return ZEROS.slice(0, n - val.length) + val + " "; + } + function encodeSizeBin(num, buf, off) { + buf[off] = 128; + for (let i = 11; i > 0; i--) { + buf[off + i] = num & 255; + num = Math.floor(num / 256); + } + } + function encodeSize(num, buf, off) { + if (num.toString(8).length > 11) { + encodeSizeBin(num, buf, off); + } else { + b4a.write(buf, encodeOct(num, 11), off); + } + } + function parse256(buf) { + let positive; + if (buf[0] === 128) + positive = true; + else if (buf[0] === 255) + positive = false; + else + return null; + const tuple = []; + let i; + for (i = buf.length - 1; i > 0; i--) { + const byte = buf[i]; + if (positive) + tuple.push(byte); + else + tuple.push(255 - byte); + } + let sum = 0; + const l = tuple.length; + for (i = 0; i < l; i++) { + sum += tuple[i] * Math.pow(256, i); + } + return positive ? sum : -1 * sum; + } + function decodeOct(val, offset, length) { + val = val.subarray(offset, offset + length); + offset = 0; + if (val[offset] & 128) { + return parse256(val); + } else { + while (offset < val.length && val[offset] === 32) + offset++; + const end = clamp(indexOf(val, 32, offset, val.length), val.length, val.length); + while (offset < end && val[offset] === 0) + offset++; + if (end === offset) + return 0; + return parseInt(b4a.toString(val.subarray(offset, end)), 8); + } + } + function decodeStr(val, offset, length, encoding) { + return b4a.toString(val.subarray(offset, indexOf(val, 0, offset, offset + length)), encoding); + } + function addLength(str) { + const len = b4a.byteLength(str); + let digits = Math.floor(Math.log(len) / Math.log(10)) + 1; + if (len + digits >= Math.pow(10, digits)) + digits++; + return len + digits + str; + } + } +}); + +// ../testeranto/node_modules/tar-stream/extract.js +var require_extract = __commonJS({ + "../testeranto/node_modules/tar-stream/extract.js"(exports, module) { + init_cjs_shim(); + var { Writable, Readable, getStreamError } = require_streamx(); + var FIFO = require_fast_fifo(); + var b4a = require_b4a(); + var headers = require_headers(); + var EMPTY = b4a.alloc(0); + var BufferList = class { + constructor() { + this.buffered = 0; + this.shifted = 0; + this.queue = new FIFO(); + this._offset = 0; + } + push(buffer) { + this.buffered += buffer.byteLength; + this.queue.push(buffer); + } + shiftFirst(size) { + return this._buffered === 0 ? null : this._next(size); + } + shift(size) { + if (size > this.buffered) + return null; + if (size === 0) + return EMPTY; + let chunk = this._next(size); + if (size === chunk.byteLength) + return chunk; + const chunks = [chunk]; + while ((size -= chunk.byteLength) > 0) { + chunk = this._next(size); + chunks.push(chunk); + } + return b4a.concat(chunks); + } + _next(size) { + const buf = this.queue.peek(); + const rem = buf.byteLength - this._offset; + if (size >= rem) { + const sub = this._offset ? buf.subarray(this._offset, buf.byteLength) : buf; + this.queue.shift(); + this._offset = 0; + this.buffered -= rem; + this.shifted += rem; + return sub; + } + this.buffered -= size; + this.shifted += size; + return buf.subarray(this._offset, this._offset += size); + } + }; + var Source = class extends Readable { + constructor(self2, header, offset) { + super(); + this.header = header; + this.offset = offset; + this._parent = self2; + } + _read(cb) { + if (this.header.size === 0) { + this.push(null); + } + if (this._parent._stream === this) { + this._parent._update(); + } + cb(null); + } + _predestroy() { + this._parent.destroy(getStreamError(this)); + } + _detach() { + if (this._parent._stream === this) { + this._parent._stream = null; + this._parent._missing = overflow(this.header.size); + this._parent._update(); + } + } + _destroy(cb) { + this._detach(); + cb(null); + } + }; + var Extract = class extends Writable { + constructor(opts) { + super(opts); + if (!opts) + opts = {}; + this._buffer = new BufferList(); + this._offset = 0; + this._header = null; + this._stream = null; + this._missing = 0; + this._longHeader = false; + this._callback = noop; + this._locked = false; + this._finished = false; + this._pax = null; + this._paxGlobal = null; + this._gnuLongPath = null; + this._gnuLongLinkPath = null; + this._filenameEncoding = opts.filenameEncoding || "utf-8"; + this._allowUnknownFormat = !!opts.allowUnknownFormat; + this._unlockBound = this._unlock.bind(this); + } + _unlock(err) { + this._locked = false; + if (err) { + this.destroy(err); + this._continueWrite(err); + return; + } + this._update(); + } + _consumeHeader() { + if (this._locked) + return false; + this._offset = this._buffer.shifted; + try { + this._header = headers.decode(this._buffer.shift(512), this._filenameEncoding, this._allowUnknownFormat); + } catch (err) { + this._continueWrite(err); + return false; + } + if (!this._header) + return true; + switch (this._header.type) { + case "gnu-long-path": + case "gnu-long-link-path": + case "pax-global-header": + case "pax-header": + this._longHeader = true; + this._missing = this._header.size; + return true; + } + this._locked = true; + this._applyLongHeaders(); + if (this._header.size === 0 || this._header.type === "directory") { + this.emit("entry", this._header, this._createStream(), this._unlockBound); + return true; + } + this._stream = this._createStream(); + this._missing = this._header.size; + this.emit("entry", this._header, this._stream, this._unlockBound); + return true; + } + _applyLongHeaders() { + if (this._gnuLongPath) { + this._header.name = this._gnuLongPath; + this._gnuLongPath = null; + } + if (this._gnuLongLinkPath) { + this._header.linkname = this._gnuLongLinkPath; + this._gnuLongLinkPath = null; + } + if (this._pax) { + if (this._pax.path) + this._header.name = this._pax.path; + if (this._pax.linkpath) + this._header.linkname = this._pax.linkpath; + if (this._pax.size) + this._header.size = parseInt(this._pax.size, 10); + this._header.pax = this._pax; + this._pax = null; + } + } + _decodeLongHeader(buf) { + switch (this._header.type) { + case "gnu-long-path": + this._gnuLongPath = headers.decodeLongPath(buf, this._filenameEncoding); + break; + case "gnu-long-link-path": + this._gnuLongLinkPath = headers.decodeLongPath(buf, this._filenameEncoding); + break; + case "pax-global-header": + this._paxGlobal = headers.decodePax(buf); + break; + case "pax-header": + this._pax = this._paxGlobal === null ? headers.decodePax(buf) : Object.assign({}, this._paxGlobal, headers.decodePax(buf)); + break; + } + } + _consumeLongHeader() { + this._longHeader = false; + this._missing = overflow(this._header.size); + const buf = this._buffer.shift(this._header.size); + try { + this._decodeLongHeader(buf); + } catch (err) { + this._continueWrite(err); + return false; + } + return true; + } + _consumeStream() { + const buf = this._buffer.shiftFirst(this._missing); + if (buf === null) + return false; + this._missing -= buf.byteLength; + const drained = this._stream.push(buf); + if (this._missing === 0) { + this._stream.push(null); + if (drained) + this._stream._detach(); + return drained && this._locked === false; + } + return drained; + } + _createStream() { + return new Source(this, this._header, this._offset); + } + _update() { + while (this._buffer.buffered > 0 && !this.destroying) { + if (this._missing > 0) { + if (this._stream !== null) { + if (this._consumeStream() === false) + return; + continue; + } + if (this._longHeader === true) { + if (this._missing > this._buffer.buffered) + break; + if (this._consumeLongHeader() === false) + return false; + continue; + } + const ignore = this._buffer.shiftFirst(this._missing); + if (ignore !== null) + this._missing -= ignore.byteLength; + continue; + } + if (this._buffer.buffered < 512) + break; + if (this._stream !== null || this._consumeHeader() === false) + return; + } + this._continueWrite(null); + } + _continueWrite(err) { + const cb = this._callback; + this._callback = noop; + cb(err); + } + _write(data, cb) { + this._callback = cb; + this._buffer.push(data); + this._update(); + } + _final(cb) { + this._finished = this._missing === 0 && this._buffer.buffered === 0; + cb(this._finished ? null : new Error("Unexpected end of data")); + } + _predestroy() { + this._continueWrite(null); + } + _destroy(cb) { + if (this._stream) + this._stream.destroy(getStreamError(this)); + cb(null); + } + [Symbol.asyncIterator]() { + let error = null; + let promiseResolve = null; + let promiseReject = null; + let entryStream = null; + let entryCallback = null; + const extract = this; + this.on("entry", onentry); + this.on("error", (err) => { + error = err; + }); + this.on("close", onclose); + return { + [Symbol.asyncIterator]() { + return this; + }, + next() { + return new Promise(onnext); + }, + return() { + return destroy(null); + }, + throw(err) { + return destroy(err); + } + }; + function consumeCallback(err) { + if (!entryCallback) + return; + const cb = entryCallback; + entryCallback = null; + cb(err); + } + function onnext(resolve5, reject) { + if (error) { + return reject(error); + } + if (entryStream) { + resolve5({ value: entryStream, done: false }); + entryStream = null; + return; + } + promiseResolve = resolve5; + promiseReject = reject; + consumeCallback(null); + if (extract._finished && promiseResolve) { + promiseResolve({ value: void 0, done: true }); + promiseResolve = promiseReject = null; + } + } + function onentry(header, stream, callback) { + entryCallback = callback; + stream.on("error", noop); + if (promiseResolve) { + promiseResolve({ value: stream, done: false }); + promiseResolve = promiseReject = null; + } else { + entryStream = stream; + } + } + function onclose() { + consumeCallback(error); + if (!promiseResolve) + return; + if (error) + promiseReject(error); + else + promiseResolve({ value: void 0, done: true }); + promiseResolve = promiseReject = null; + } + function destroy(err) { + extract.destroy(err); + consumeCallback(err); + return new Promise((resolve5, reject) => { + if (extract.destroyed) + return resolve5({ value: void 0, done: true }); + extract.once("close", function() { + if (err) + reject(err); + else + resolve5({ value: void 0, done: true }); + }); + }); + } + } + }; + module.exports = function extract(opts) { + return new Extract(opts); + }; + function noop() { + } + function overflow(size) { + size &= 511; + return size && 512 - size; + } + } +}); + +// ../testeranto/node_modules/tar-stream/constants.js +var require_constants5 = __commonJS({ + "../testeranto/node_modules/tar-stream/constants.js"(exports, module) { + init_cjs_shim(); + var constants = { + // just for envs without fs + S_IFMT: 61440, + S_IFDIR: 16384, + S_IFCHR: 8192, + S_IFBLK: 24576, + S_IFIFO: 4096, + S_IFLNK: 40960 + }; + try { + module.exports = __require("fs").constants || constants; + } catch { + module.exports = constants; + } + } +}); + +// ../testeranto/node_modules/tar-stream/pack.js +var require_pack = __commonJS({ + "../testeranto/node_modules/tar-stream/pack.js"(exports, module) { + init_cjs_shim(); + var { Readable, Writable, getStreamError } = require_streamx(); + var b4a = require_b4a(); + var constants = require_constants5(); + var headers = require_headers(); + var DMODE = 493; + var FMODE = 420; + var END_OF_TAR = b4a.alloc(1024); + var Sink = class extends Writable { + constructor(pack, header, callback) { + super({ mapWritable, eagerOpen: true }); + this.written = 0; + this.header = header; + this._callback = callback; + this._linkname = null; + this._isLinkname = header.type === "symlink" && !header.linkname; + this._isVoid = header.type !== "file" && header.type !== "contiguous-file"; + this._finished = false; + this._pack = pack; + this._openCallback = null; + if (this._pack._stream === null) + this._pack._stream = this; + else + this._pack._pending.push(this); + } + _open(cb) { + this._openCallback = cb; + if (this._pack._stream === this) + this._continueOpen(); + } + _continuePack(err) { + if (this._callback === null) + return; + const callback = this._callback; + this._callback = null; + callback(err); + } + _continueOpen() { + if (this._pack._stream === null) + this._pack._stream = this; + const cb = this._openCallback; + this._openCallback = null; + if (cb === null) + return; + if (this._pack.destroying) + return cb(new Error("pack stream destroyed")); + if (this._pack._finalized) + return cb(new Error("pack stream is already finalized")); + this._pack._stream = this; + if (!this._isLinkname) { + this._pack._encode(this.header); + } + if (this._isVoid) { + this._finish(); + this._continuePack(null); + } + cb(null); + } + _write(data, cb) { + if (this._isLinkname) { + this._linkname = this._linkname ? b4a.concat([this._linkname, data]) : data; + return cb(null); + } + if (this._isVoid) { + if (data.byteLength > 0) { + return cb(new Error("No body allowed for this entry")); + } + return cb(); + } + this.written += data.byteLength; + if (this._pack.push(data)) + return cb(); + this._pack._drain = cb; + } + _finish() { + if (this._finished) + return; + this._finished = true; + if (this._isLinkname) { + this.header.linkname = this._linkname ? b4a.toString(this._linkname, "utf-8") : ""; + this._pack._encode(this.header); + } + overflow(this._pack, this.header.size); + this._pack._done(this); + } + _final(cb) { + if (this.written !== this.header.size) { + return cb(new Error("Size mismatch")); + } + this._finish(); + cb(null); + } + _getError() { + return getStreamError(this) || new Error("tar entry destroyed"); + } + _predestroy() { + this._pack.destroy(this._getError()); + } + _destroy(cb) { + this._pack._done(this); + this._continuePack(this._finished ? null : this._getError()); + cb(); + } + }; + var Pack = class extends Readable { + constructor(opts) { + super(opts); + this._drain = noop; + this._finalized = false; + this._finalizing = false; + this._pending = []; + this._stream = null; + } + entry(header, buffer, callback) { + if (this._finalized || this.destroying) + throw new Error("already finalized or destroyed"); + if (typeof buffer === "function") { + callback = buffer; + buffer = null; + } + if (!callback) + callback = noop; + if (!header.size || header.type === "symlink") + header.size = 0; + if (!header.type) + header.type = modeToType(header.mode); + if (!header.mode) + header.mode = header.type === "directory" ? DMODE : FMODE; + if (!header.uid) + header.uid = 0; + if (!header.gid) + header.gid = 0; + if (!header.mtime) + header.mtime = /* @__PURE__ */ new Date(); + if (typeof buffer === "string") + buffer = b4a.from(buffer); + const sink = new Sink(this, header, callback); + if (b4a.isBuffer(buffer)) { + header.size = buffer.byteLength; + sink.write(buffer); + sink.end(); + return sink; + } + if (sink._isVoid) { + return sink; + } + return sink; + } + finalize() { + if (this._stream || this._pending.length > 0) { + this._finalizing = true; + return; + } + if (this._finalized) + return; + this._finalized = true; + this.push(END_OF_TAR); + this.push(null); + } + _done(stream) { + if (stream !== this._stream) + return; + this._stream = null; + if (this._finalizing) + this.finalize(); + if (this._pending.length) + this._pending.shift()._continueOpen(); + } + _encode(header) { + if (!header.pax) { + const buf = headers.encode(header); + if (buf) { + this.push(buf); + return; + } + } + this._encodePax(header); + } + _encodePax(header) { + const paxHeader = headers.encodePax({ + name: header.name, + linkname: header.linkname, + pax: header.pax + }); + const newHeader = { + name: "PaxHeader", + mode: header.mode, + uid: header.uid, + gid: header.gid, + size: paxHeader.byteLength, + mtime: header.mtime, + type: "pax-header", + linkname: header.linkname && "PaxHeader", + uname: header.uname, + gname: header.gname, + devmajor: header.devmajor, + devminor: header.devminor + }; + this.push(headers.encode(newHeader)); + this.push(paxHeader); + overflow(this, paxHeader.byteLength); + newHeader.size = header.size; + newHeader.type = header.type; + this.push(headers.encode(newHeader)); + } + _doDrain() { + const drain = this._drain; + this._drain = noop; + drain(); + } + _predestroy() { + const err = getStreamError(this); + if (this._stream) + this._stream.destroy(err); + while (this._pending.length) { + const stream = this._pending.shift(); + stream.destroy(err); + stream._continueOpen(); + } + this._doDrain(); + } + _read(cb) { + this._doDrain(); + cb(); + } + }; + module.exports = function pack(opts) { + return new Pack(opts); + }; + function modeToType(mode) { + switch (mode & constants.S_IFMT) { + case constants.S_IFBLK: + return "block-device"; + case constants.S_IFCHR: + return "character-device"; + case constants.S_IFDIR: + return "directory"; + case constants.S_IFIFO: + return "fifo"; + case constants.S_IFLNK: + return "symlink"; + } + return "file"; + } + function noop() { + } + function overflow(self2, size) { + size &= 511; + if (size) + self2.push(END_OF_TAR.subarray(0, 512 - size)); + } + function mapWritable(buf) { + return b4a.isBuffer(buf) ? buf : b4a.from(buf); + } + } +}); + +// ../testeranto/node_modules/tar-stream/index.js +var require_tar_stream = __commonJS({ + "../testeranto/node_modules/tar-stream/index.js"(exports) { + init_cjs_shim(); + exports.extract = require_extract(); + exports.pack = require_pack(); + } +}); + +// ../testeranto/node_modules/tar-fs/index.js +var require_tar_fs = __commonJS({ + "../testeranto/node_modules/tar-fs/index.js"(exports) { + init_cjs_shim(); + var tar2 = require_tar_stream(); + var pump = require_pump(); + var fs6 = __require("fs"); + var path10 = __require("path"); + var win32 = (global.Bare?.platform || process.platform) === "win32"; + exports.pack = function pack(cwd, opts) { + if (!cwd) + cwd = "."; + if (!opts) + opts = {}; + const xfs = opts.fs || fs6; + const ignore = opts.ignore || opts.filter || noop; + const mapStream = opts.mapStream || echo; + const statNext = statAll(xfs, opts.dereference ? xfs.stat : xfs.lstat, cwd, ignore, opts.entries, opts.sort); + const strict = opts.strict !== false; + const umask = typeof opts.umask === "number" ? ~opts.umask : ~processUmask(); + const pack2 = opts.pack || tar2.pack(); + const finish = opts.finish || noop; + let map2 = opts.map || noop; + let dmode = typeof opts.dmode === "number" ? opts.dmode : 0; + let fmode = typeof opts.fmode === "number" ? opts.fmode : 0; + if (opts.strip) + map2 = strip(map2, opts.strip); + if (opts.readable) { + dmode |= parseInt(555, 8); + fmode |= parseInt(444, 8); + } + if (opts.writable) { + dmode |= parseInt(333, 8); + fmode |= parseInt(222, 8); + } + onnextentry(); + function onsymlink(filename, header) { + xfs.readlink(path10.join(cwd, filename), function(err, linkname) { + if (err) + return pack2.destroy(err); + header.linkname = normalize2(linkname); + pack2.entry(header, onnextentry); + }); + } + function onstat(err, filename, stat) { + if (pack2.destroyed) + return; + if (err) + return pack2.destroy(err); + if (!filename) { + if (opts.finalize !== false) + pack2.finalize(); + return finish(pack2); + } + if (stat.isSocket()) + return onnextentry(); + let header = { + name: normalize2(filename), + mode: (stat.mode | (stat.isDirectory() ? dmode : fmode)) & umask, + mtime: stat.mtime, + size: stat.size, + type: "file", + uid: stat.uid, + gid: stat.gid + }; + if (stat.isDirectory()) { + header.size = 0; + header.type = "directory"; + header = map2(header) || header; + return pack2.entry(header, onnextentry); + } + if (stat.isSymbolicLink()) { + header.size = 0; + header.type = "symlink"; + header = map2(header) || header; + return onsymlink(filename, header); + } + header = map2(header) || header; + if (!stat.isFile()) { + if (strict) + return pack2.destroy(new Error("unsupported type for " + filename)); + return onnextentry(); + } + const entry = pack2.entry(header, onnextentry); + const rs = mapStream(xfs.createReadStream(path10.join(cwd, filename), { start: 0, end: header.size > 0 ? header.size - 1 : header.size }), header); + rs.on("error", function(err2) { + entry.destroy(err2); + }); + pump(rs, entry); + } + function onnextentry(err) { + if (err) + return pack2.destroy(err); + statNext(onstat); + } + return pack2; + }; + function head(list) { + return list.length ? list[list.length - 1] : null; + } + function processGetuid() { + return process.getuid ? process.getuid() : -1; + } + function processUmask() { + return process.umask ? process.umask() : 0; + } + exports.extract = function extract(cwd, opts) { + if (!cwd) + cwd = "."; + if (!opts) + opts = {}; + const xfs = opts.fs || fs6; + const ignore = opts.ignore || opts.filter || noop; + const mapStream = opts.mapStream || echo; + const own = opts.chown !== false && !win32 && processGetuid() === 0; + const extract2 = opts.extract || tar2.extract(); + const stack = []; + const now = /* @__PURE__ */ new Date(); + const umask = typeof opts.umask === "number" ? ~opts.umask : ~processUmask(); + const strict = opts.strict !== false; + let map2 = opts.map || noop; + let dmode = typeof opts.dmode === "number" ? opts.dmode : 0; + let fmode = typeof opts.fmode === "number" ? opts.fmode : 0; + if (opts.strip) + map2 = strip(map2, opts.strip); + if (opts.readable) { + dmode |= parseInt(555, 8); + fmode |= parseInt(444, 8); + } + if (opts.writable) { + dmode |= parseInt(333, 8); + fmode |= parseInt(222, 8); + } + extract2.on("entry", onentry); + if (opts.finish) + extract2.on("finish", opts.finish); + return extract2; + function onentry(header, stream, next) { + header = map2(header) || header; + header.name = normalize2(header.name); + const name = path10.join(cwd, path10.join("/", header.name)); + if (ignore(name, header)) { + stream.resume(); + return next(); + } + if (header.type === "directory") { + stack.push([name, header.mtime]); + return mkdirfix(name, { + fs: xfs, + own, + uid: header.uid, + gid: header.gid, + mode: header.mode + }, stat); + } + const dir = path10.dirname(name); + validate(xfs, dir, path10.join(cwd, "."), function(err, valid) { + if (err) + return next(err); + if (!valid) + return next(new Error(dir + " is not a valid path")); + mkdirfix(dir, { + fs: xfs, + own, + uid: header.uid, + gid: header.gid, + // normally, the folders with rights and owner should be part of the TAR file + // if this is not the case, create folder for same user as file and with + // standard permissions of 0o755 (rwxr-xr-x) + mode: 493 + }, function(err2) { + if (err2) + return next(err2); + switch (header.type) { + case "file": + return onfile(); + case "link": + return onlink(); + case "symlink": + return onsymlink(); + } + if (strict) + return next(new Error("unsupported type for " + name + " (" + header.type + ")")); + stream.resume(); + next(); + }); + }); + function stat(err) { + if (err) + return next(err); + utimes(name, header, function(err2) { + if (err2) + return next(err2); + if (win32) + return next(); + chperm(name, header, next); + }); + } + function onsymlink() { + if (win32) + return next(); + xfs.unlink(name, function() { + xfs.symlink(header.linkname, name, stat); + }); + } + function onlink() { + if (win32) + return next(); + xfs.unlink(name, function() { + const srcpath = path10.join(cwd, path10.join("/", header.linkname)); + xfs.link(srcpath, name, function(err) { + if (err && err.code === "EPERM" && opts.hardlinkAsFilesFallback) { + stream = xfs.createReadStream(srcpath); + return onfile(); + } + stat(err); + }); + }); + } + function onfile() { + const ws = xfs.createWriteStream(name); + const rs = mapStream(stream, header); + ws.on("error", function(err) { + rs.destroy(err); + }); + pump(rs, ws, function(err) { + if (err) + return next(err); + ws.on("close", stat); + }); + } + } + function utimesParent(name, cb) { + let top2; + while ((top2 = head(stack)) && name.slice(0, top2[0].length) !== top2[0]) + stack.pop(); + if (!top2) + return cb(); + xfs.utimes(top2[0], now, top2[1], cb); + } + function utimes(name, header, cb) { + if (opts.utimes === false) + return cb(); + if (header.type === "directory") + return xfs.utimes(name, now, header.mtime, cb); + if (header.type === "symlink") + return utimesParent(name, cb); + xfs.utimes(name, now, header.mtime, function(err) { + if (err) + return cb(err); + utimesParent(name, cb); + }); + } + function chperm(name, header, cb) { + const link = header.type === "symlink"; + const chmod = link ? xfs.lchmod : xfs.chmod; + const chown = link ? xfs.lchown : xfs.chown; + if (!chmod) + return cb(); + const mode = (header.mode | (header.type === "directory" ? dmode : fmode)) & umask; + if (chown && own) + chown.call(xfs, name, header.uid, header.gid, onchown); + else + onchown(null); + function onchown(err) { + if (err) + return cb(err); + if (!chmod) + return cb(); + chmod.call(xfs, name, mode, cb); + } + } + function mkdirfix(name, opts2, cb) { + xfs.stat(name, function(err) { + if (!err) + return cb(null); + if (err.code !== "ENOENT") + return cb(err); + xfs.mkdir(name, { mode: opts2.mode, recursive: true }, function(err2, made) { + if (err2) + return cb(err2); + chperm(name, opts2, cb); + }); + }); + } + }; + function validate(fs7, name, root, cb) { + if (name === root) + return cb(null, true); + fs7.lstat(name, function(err, st) { + if (err && err.code === "ENOENT") + return validate(fs7, path10.join(name, ".."), root, cb); + else if (err) + return cb(err); + cb(null, st.isDirectory()); + }); + } + function noop() { + } + function echo(name) { + return name; + } + function normalize2(name) { + return win32 ? name.replace(/\\/g, "/").replace(/[:?<>|]/g, "_") : name; + } + function statAll(fs7, stat, cwd, ignore, entries, sort) { + if (!entries) + entries = ["."]; + const queue = entries.slice(0); + return function loop(callback) { + if (!queue.length) + return callback(null); + const next = queue.shift(); + const nextAbs = path10.join(cwd, next); + stat.call(fs7, nextAbs, function(err, stat2) { + if (err) + return callback(entries.indexOf(next) === -1 && err.code === "ENOENT" ? null : err); + if (!stat2.isDirectory()) + return callback(null, next, stat2); + fs7.readdir(nextAbs, function(err2, files) { + if (err2) + return callback(err2); + if (sort) + files.sort(); + for (let i = 0; i < files.length; i++) { + if (!ignore(path10.join(cwd, next, files[i]))) + queue.push(path10.join(next, files[i])); + } + callback(null, next, stat2); + }); + }); + }; + } + function strip(map2, level) { + return function(header) { + header.name = header.name.split("/").slice(level).join("/"); + const linkname = header.linkname; + if (linkname && (header.type === "link" || path10.isAbsolute(linkname))) { + header.linkname = linkname.split("/").slice(level).join("/"); + } + return map2(header); + }; + } + } +}); + +// ../testeranto/node_modules/through/index.js +var require_through = __commonJS({ + "../testeranto/node_modules/through/index.js"(exports, module) { + init_cjs_shim(); + var Stream = __require("stream"); + exports = module.exports = through; + through.through = through; + function through(write, end, opts) { + write = write || function(data) { + this.queue(data); + }; + end = end || function() { + this.queue(null); + }; + var ended = false, destroyed = false, buffer = [], _ended = false; + var stream = new Stream(); + stream.readable = stream.writable = true; + stream.paused = false; + stream.autoDestroy = !(opts && opts.autoDestroy === false); + stream.write = function(data) { + write.call(this, data); + return !stream.paused; + }; + function drain() { + while (buffer.length && !stream.paused) { + var data = buffer.shift(); + if (null === data) + return stream.emit("end"); + else + stream.emit("data", data); + } + } + stream.queue = stream.push = function(data) { + if (_ended) + return stream; + if (data === null) + _ended = true; + buffer.push(data); + drain(); + return stream; + }; + stream.on("end", function() { + stream.readable = false; + if (!stream.writable && stream.autoDestroy) + process.nextTick(function() { + stream.destroy(); + }); + }); + function _end() { + stream.writable = false; + end.call(stream); + if (!stream.readable && stream.autoDestroy) + stream.destroy(); + } + stream.end = function(data) { + if (ended) + return; + ended = true; + if (arguments.length) + stream.write(data); + _end(); + return stream; + }; + stream.destroy = function() { + if (destroyed) + return; + destroyed = true; + ended = true; + buffer.length = 0; + stream.writable = stream.readable = false; + stream.emit("close"); + return stream; + }; + stream.pause = function() { + if (stream.paused) + return; + stream.paused = true; + return stream; + }; + stream.resume = function() { + if (stream.paused) { + stream.paused = false; + stream.emit("resume"); + } + drain(); + if (!stream.paused) + stream.emit("drain"); + return stream; + }; + return stream; + } + } +}); + +// ../testeranto/node_modules/unbzip2-stream/lib/bzip2.js +var require_bzip2 = __commonJS({ + "../testeranto/node_modules/unbzip2-stream/lib/bzip2.js"(exports, module) { + init_cjs_shim(); + function Bzip2Error(message2) { + this.name = "Bzip2Error"; + this.message = message2; + this.stack = new Error().stack; + } + Bzip2Error.prototype = new Error(); + var message = { + Error: function(message2) { + throw new Bzip2Error(message2); + } + }; + var bzip2 = {}; + bzip2.Bzip2Error = Bzip2Error; + bzip2.crcTable = [ + 0, + 79764919, + 159529838, + 222504665, + 319059676, + 398814059, + 445009330, + 507990021, + 638119352, + 583659535, + 797628118, + 726387553, + 890018660, + 835552979, + 1015980042, + 944750013, + 1276238704, + 1221641927, + 1167319070, + 1095957929, + 1595256236, + 1540665371, + 1452775106, + 1381403509, + 1780037320, + 1859660671, + 1671105958, + 1733955601, + 2031960084, + 2111593891, + 1889500026, + 1952343757, + 2552477408, + 2632100695, + 2443283854, + 2506133561, + 2334638140, + 2414271883, + 2191915858, + 2254759653, + 3190512472, + 3135915759, + 3081330742, + 3009969537, + 2905550212, + 2850959411, + 2762807018, + 2691435357, + 3560074640, + 3505614887, + 3719321342, + 3648080713, + 3342211916, + 3287746299, + 3467911202, + 3396681109, + 4063920168, + 4143685023, + 4223187782, + 4286162673, + 3779000052, + 3858754371, + 3904687514, + 3967668269, + 881225847, + 809987520, + 1023691545, + 969234094, + 662832811, + 591600412, + 771767749, + 717299826, + 311336399, + 374308984, + 453813921, + 533576470, + 25881363, + 88864420, + 134795389, + 214552010, + 2023205639, + 2086057648, + 1897238633, + 1976864222, + 1804852699, + 1867694188, + 1645340341, + 1724971778, + 1587496639, + 1516133128, + 1461550545, + 1406951526, + 1302016099, + 1230646740, + 1142491917, + 1087903418, + 2896545431, + 2825181984, + 2770861561, + 2716262478, + 3215044683, + 3143675388, + 3055782693, + 3001194130, + 2326604591, + 2389456536, + 2200899649, + 2280525302, + 2578013683, + 2640855108, + 2418763421, + 2498394922, + 3769900519, + 3832873040, + 3912640137, + 3992402750, + 4088425275, + 4151408268, + 4197601365, + 4277358050, + 3334271071, + 3263032808, + 3476998961, + 3422541446, + 3585640067, + 3514407732, + 3694837229, + 3640369242, + 1762451694, + 1842216281, + 1619975040, + 1682949687, + 2047383090, + 2127137669, + 1938468188, + 2001449195, + 1325665622, + 1271206113, + 1183200824, + 1111960463, + 1543535498, + 1489069629, + 1434599652, + 1363369299, + 622672798, + 568075817, + 748617968, + 677256519, + 907627842, + 853037301, + 1067152940, + 995781531, + 51762726, + 131386257, + 177728840, + 240578815, + 269590778, + 349224269, + 429104020, + 491947555, + 4046411278, + 4126034873, + 4172115296, + 4234965207, + 3794477266, + 3874110821, + 3953728444, + 4016571915, + 3609705398, + 3555108353, + 3735388376, + 3664026991, + 3290680682, + 3236090077, + 3449943556, + 3378572211, + 3174993278, + 3120533705, + 3032266256, + 2961025959, + 2923101090, + 2868635157, + 2813903052, + 2742672763, + 2604032198, + 2683796849, + 2461293480, + 2524268063, + 2284983834, + 2364738477, + 2175806836, + 2238787779, + 1569362073, + 1498123566, + 1409854455, + 1355396672, + 1317987909, + 1246755826, + 1192025387, + 1137557660, + 2072149281, + 2135122070, + 1912620623, + 1992383480, + 1753615357, + 1816598090, + 1627664531, + 1707420964, + 295390185, + 358241886, + 404320391, + 483945776, + 43990325, + 106832002, + 186451547, + 266083308, + 932423249, + 861060070, + 1041341759, + 986742920, + 613929101, + 542559546, + 756411363, + 701822548, + 3316196985, + 3244833742, + 3425377559, + 3370778784, + 3601682597, + 3530312978, + 3744426955, + 3689838204, + 3819031489, + 3881883254, + 3928223919, + 4007849240, + 4037393693, + 4100235434, + 4180117107, + 4259748804, + 2310601993, + 2373574846, + 2151335527, + 2231098320, + 2596047829, + 2659030626, + 2470359227, + 2550115596, + 2947551409, + 2876312838, + 2788305887, + 2733848168, + 3165939309, + 3094707162, + 3040238851, + 2985771188 + ]; + bzip2.array = function(bytes) { + var bit = 0, byte = 0; + var BITMASK = [0, 1, 3, 7, 15, 31, 63, 127, 255]; + return function(n) { + var result = 0; + while (n > 0) { + var left2 = 8 - bit; + if (n >= left2) { + result <<= left2; + result |= BITMASK[left2] & bytes[byte++]; + bit = 0; + n -= left2; + } else { + result <<= n; + result |= (bytes[byte] & BITMASK[n] << 8 - n - bit) >> 8 - n - bit; + bit += n; + n = 0; + } + } + return result; + }; + }; + bzip2.simple = function(srcbuffer, stream) { + var bits = bzip2.array(srcbuffer); + var size = bzip2.header(bits); + var ret = false; + var bufsize = 1e5 * size; + var buf = new Int32Array(bufsize); + do { + ret = bzip2.decompress(bits, stream, buf, bufsize); + } while (!ret); + }; + bzip2.header = function(bits) { + this.byteCount = new Int32Array(256); + this.symToByte = new Uint8Array(256); + this.mtfSymbol = new Int32Array(256); + this.selectors = new Uint8Array(32768); + if (bits(8 * 3) != 4348520) + message.Error("No magic number found"); + var i = bits(8) - 48; + if (i < 1 || i > 9) + message.Error("Not a BZIP archive"); + return i; + }; + bzip2.decompress = function(bits, stream, buf, bufsize, streamCRC) { + var MAX_HUFCODE_BITS = 20; + var MAX_SYMBOLS = 258; + var SYMBOL_RUNA = 0; + var SYMBOL_RUNB = 1; + var GROUP_SIZE = 50; + var crc = 0 ^ -1; + for (var h = "", i = 0; i < 6; i++) + h += bits(8).toString(16); + if (h == "177245385090") { + var finalCRC = bits(32) | 0; + if (finalCRC !== streamCRC) + message.Error("Error in bzip2: crc32 do not match"); + bits(null); + return null; + } + if (h != "314159265359") + message.Error("eek not valid bzip data"); + var crcblock = bits(32) | 0; + if (bits(1)) + message.Error("unsupported obsolete version"); + var origPtr = bits(24); + if (origPtr > bufsize) + message.Error("Initial position larger than buffer size"); + var t = bits(16); + var symTotal = 0; + for (i = 0; i < 16; i++) { + if (t & 1 << 15 - i) { + var k = bits(16); + for (j = 0; j < 16; j++) { + if (k & 1 << 15 - j) { + this.symToByte[symTotal++] = 16 * i + j; + } + } + } + } + var groupCount = bits(3); + if (groupCount < 2 || groupCount > 6) + message.Error("another error"); + var nSelectors = bits(15); + if (nSelectors == 0) + message.Error("meh"); + for (var i = 0; i < groupCount; i++) + this.mtfSymbol[i] = i; + for (var i = 0; i < nSelectors; i++) { + for (var j = 0; bits(1); j++) + if (j >= groupCount) + message.Error("whoops another error"); + var uc = this.mtfSymbol[j]; + for (var k = j - 1; k >= 0; k--) { + this.mtfSymbol[k + 1] = this.mtfSymbol[k]; + } + this.mtfSymbol[0] = uc; + this.selectors[i] = uc; + } + var symCount = symTotal + 2; + var groups = []; + var length = new Uint8Array(MAX_SYMBOLS), temp = new Uint16Array(MAX_HUFCODE_BITS + 1); + var hufGroup; + for (var j = 0; j < groupCount; j++) { + t = bits(5); + for (var i = 0; i < symCount; i++) { + while (true) { + if (t < 1 || t > MAX_HUFCODE_BITS) + message.Error("I gave up a while ago on writing error messages"); + if (!bits(1)) + break; + if (!bits(1)) + t++; + else + t--; + } + length[i] = t; + } + var minLen, maxLen; + minLen = maxLen = length[0]; + for (var i = 1; i < symCount; i++) { + if (length[i] > maxLen) + maxLen = length[i]; + else if (length[i] < minLen) + minLen = length[i]; + } + hufGroup = groups[j] = {}; + hufGroup.permute = new Int32Array(MAX_SYMBOLS); + hufGroup.limit = new Int32Array(MAX_HUFCODE_BITS + 1); + hufGroup.base = new Int32Array(MAX_HUFCODE_BITS + 1); + hufGroup.minLen = minLen; + hufGroup.maxLen = maxLen; + var base = hufGroup.base; + var limit = hufGroup.limit; + var pp = 0; + for (var i = minLen; i <= maxLen; i++) + for (var t = 0; t < symCount; t++) + if (length[t] == i) + hufGroup.permute[pp++] = t; + for (i = minLen; i <= maxLen; i++) + temp[i] = limit[i] = 0; + for (i = 0; i < symCount; i++) + temp[length[i]]++; + pp = t = 0; + for (i = minLen; i < maxLen; i++) { + pp += temp[i]; + limit[i] = pp - 1; + pp <<= 1; + base[i + 1] = pp - (t += temp[i]); + } + limit[maxLen] = pp + temp[maxLen] - 1; + base[minLen] = 0; + } + for (var i = 0; i < 256; i++) { + this.mtfSymbol[i] = i; + this.byteCount[i] = 0; + } + var runPos, count, symCount, selector; + runPos = count = symCount = selector = 0; + while (true) { + if (!symCount--) { + symCount = GROUP_SIZE - 1; + if (selector >= nSelectors) + message.Error("meow i'm a kitty, that's an error"); + hufGroup = groups[this.selectors[selector++]]; + base = hufGroup.base; + limit = hufGroup.limit; + } + i = hufGroup.minLen; + j = bits(i); + while (true) { + if (i > hufGroup.maxLen) + message.Error("rawr i'm a dinosaur"); + if (j <= limit[i]) + break; + i++; + j = j << 1 | bits(1); + } + j -= base[i]; + if (j < 0 || j >= MAX_SYMBOLS) + message.Error("moo i'm a cow"); + var nextSym = hufGroup.permute[j]; + if (nextSym == SYMBOL_RUNA || nextSym == SYMBOL_RUNB) { + if (!runPos) { + runPos = 1; + t = 0; + } + if (nextSym == SYMBOL_RUNA) + t += runPos; + else + t += 2 * runPos; + runPos <<= 1; + continue; + } + if (runPos) { + runPos = 0; + if (count + t > bufsize) + message.Error("Boom."); + uc = this.symToByte[this.mtfSymbol[0]]; + this.byteCount[uc] += t; + while (t--) + buf[count++] = uc; + } + if (nextSym > symTotal) + break; + if (count >= bufsize) + message.Error("I can't think of anything. Error"); + i = nextSym - 1; + uc = this.mtfSymbol[i]; + for (var k = i - 1; k >= 0; k--) { + this.mtfSymbol[k + 1] = this.mtfSymbol[k]; + } + this.mtfSymbol[0] = uc; + uc = this.symToByte[uc]; + this.byteCount[uc]++; + buf[count++] = uc; + } + if (origPtr < 0 || origPtr >= count) + message.Error("I'm a monkey and I'm throwing something at someone, namely you"); + var j = 0; + for (var i = 0; i < 256; i++) { + k = j + this.byteCount[i]; + this.byteCount[i] = j; + j = k; + } + for (var i = 0; i < count; i++) { + uc = buf[i] & 255; + buf[this.byteCount[uc]] |= i << 8; + this.byteCount[uc]++; + } + var pos = 0, current = 0, run = 0; + if (count) { + pos = buf[origPtr]; + current = pos & 255; + pos >>= 8; + run = -1; + } + count = count; + var copies, previous, outbyte; + while (count) { + count--; + previous = current; + pos = buf[pos]; + current = pos & 255; + pos >>= 8; + if (run++ == 3) { + copies = current; + outbyte = previous; + current = -1; + } else { + copies = 1; + outbyte = current; + } + while (copies--) { + crc = (crc << 8 ^ this.crcTable[(crc >> 24 ^ outbyte) & 255]) & 4294967295; + stream(outbyte); + } + if (current != previous) + run = 0; + } + crc = (crc ^ -1) >>> 0; + if ((crc | 0) != (crcblock | 0)) + message.Error("Error in bzip2: crc32 do not match"); + streamCRC = (crc ^ (streamCRC << 1 | streamCRC >>> 31)) & 4294967295; + return streamCRC; + }; + module.exports = bzip2; + } +}); + +// ../testeranto/node_modules/unbzip2-stream/lib/bit_iterator.js +var require_bit_iterator = __commonJS({ + "../testeranto/node_modules/unbzip2-stream/lib/bit_iterator.js"(exports, module) { + init_cjs_shim(); + var BITMASK = [0, 1, 3, 7, 15, 31, 63, 127, 255]; + module.exports = function bitIterator(nextBuffer) { + var bit = 0, byte = 0; + var bytes = nextBuffer(); + var f = function(n) { + if (n === null && bit != 0) { + bit = 0; + byte++; + return; + } + var result = 0; + while (n > 0) { + if (byte >= bytes.length) { + byte = 0; + bytes = nextBuffer(); + } + var left2 = 8 - bit; + if (bit === 0 && n > 0) + f.bytesRead++; + if (n >= left2) { + result <<= left2; + result |= BITMASK[left2] & bytes[byte++]; + bit = 0; + n -= left2; + } else { + result <<= n; + result |= (bytes[byte] & BITMASK[n] << 8 - n - bit) >> 8 - n - bit; + bit += n; + n = 0; + } + } + return result; + }; + f.bytesRead = 0; + return f; + }; + } +}); + +// ../testeranto/node_modules/unbzip2-stream/index.js +var require_unbzip2_stream = __commonJS({ + "../testeranto/node_modules/unbzip2-stream/index.js"(exports, module) { + init_cjs_shim(); + var through = require_through(); + var bz2 = require_bzip2(); + var bitIterator = require_bit_iterator(); + module.exports = unbzip2Stream; + function unbzip2Stream() { + var bufferQueue = []; + var hasBytes = 0; + var blockSize = 0; + var broken = false; + var done = false; + var bitReader = null; + var streamCRC = null; + function decompressBlock(push) { + if (!blockSize) { + blockSize = bz2.header(bitReader); + streamCRC = 0; + return true; + } else { + var bufsize = 1e5 * blockSize; + var buf = new Int32Array(bufsize); + var chunk = []; + var f = function(b) { + chunk.push(b); + }; + streamCRC = bz2.decompress(bitReader, f, buf, bufsize, streamCRC); + if (streamCRC === null) { + blockSize = 0; + return false; + } else { + push(Buffer.from(chunk)); + return true; + } + } + } + var outlength = 0; + function decompressAndQueue(stream) { + if (broken) + return; + try { + return decompressBlock(function(d) { + stream.queue(d); + if (d !== null) { + outlength += d.length; + } else { + } + }); + } catch (e) { + stream.emit("error", e); + broken = true; + return false; + } + } + return through( + function write(data) { + bufferQueue.push(data); + hasBytes += data.length; + if (bitReader === null) { + bitReader = bitIterator(function() { + return bufferQueue.shift(); + }); + } + while (!broken && hasBytes - bitReader.bytesRead + 1 >= (25e3 + 1e5 * blockSize || 4)) { + decompressAndQueue(this); + } + }, + function end(x) { + while (!broken && bitReader && hasBytes > bitReader.bytesRead) { + decompressAndQueue(this); + } + if (!broken) { + if (streamCRC !== null) + this.emit("error", new Error("input stream ended prematurely")); + this.queue(null); + } + } + ); + } + } +}); + +// ../testeranto/node_modules/progress/lib/node-progress.js +var require_node_progress = __commonJS({ + "../testeranto/node_modules/progress/lib/node-progress.js"(exports, module) { + init_cjs_shim(); + exports = module.exports = ProgressBar2; + function ProgressBar2(fmt, options) { + this.stream = options.stream || process.stderr; + if (typeof options == "number") { + var total = options; + options = {}; + options.total = total; + } else { + options = options || {}; + if ("string" != typeof fmt) + throw new Error("format required"); + if ("number" != typeof options.total) + throw new Error("total required"); + } + this.fmt = fmt; + this.curr = options.curr || 0; + this.total = options.total; + this.width = options.width || this.total; + this.clear = options.clear; + this.chars = { + complete: options.complete || "=", + incomplete: options.incomplete || "-", + head: options.head || (options.complete || "=") + }; + this.renderThrottle = options.renderThrottle !== 0 ? options.renderThrottle || 16 : 0; + this.lastRender = -Infinity; + this.callback = options.callback || function() { + }; + this.tokens = {}; + this.lastDraw = ""; + } + ProgressBar2.prototype.tick = function(len, tokens) { + if (len !== 0) + len = len || 1; + if ("object" == typeof len) + tokens = len, len = 1; + if (tokens) + this.tokens = tokens; + if (0 == this.curr) + this.start = /* @__PURE__ */ new Date(); + this.curr += len; + this.render(); + if (this.curr >= this.total) { + this.render(void 0, true); + this.complete = true; + this.terminate(); + this.callback(this); + return; + } + }; + ProgressBar2.prototype.render = function(tokens, force) { + force = force !== void 0 ? force : false; + if (tokens) + this.tokens = tokens; + if (!this.stream.isTTY) + return; + var now = Date.now(); + var delta = now - this.lastRender; + if (!force && delta < this.renderThrottle) { + return; + } else { + this.lastRender = now; + } + var ratio = this.curr / this.total; + ratio = Math.min(Math.max(ratio, 0), 1); + var percent = Math.floor(ratio * 100); + var incomplete, complete, completeLength; + var elapsed = /* @__PURE__ */ new Date() - this.start; + var eta = percent == 100 ? 0 : elapsed * (this.total / this.curr - 1); + var rate = this.curr / (elapsed / 1e3); + var str = this.fmt.replace(":current", this.curr).replace(":total", this.total).replace(":elapsed", isNaN(elapsed) ? "0.0" : (elapsed / 1e3).toFixed(1)).replace(":eta", isNaN(eta) || !isFinite(eta) ? "0.0" : (eta / 1e3).toFixed(1)).replace(":percent", percent.toFixed(0) + "%").replace(":rate", Math.round(rate)); + var availableSpace = Math.max(0, this.stream.columns - str.replace(":bar", "").length); + if (availableSpace && process.platform === "win32") { + availableSpace = availableSpace - 1; + } + var width = Math.min(this.width, availableSpace); + completeLength = Math.round(width * ratio); + complete = Array(Math.max(0, completeLength + 1)).join(this.chars.complete); + incomplete = Array(Math.max(0, width - completeLength + 1)).join(this.chars.incomplete); + if (completeLength > 0) + complete = complete.slice(0, -1) + this.chars.head; + str = str.replace(":bar", complete + incomplete); + if (this.tokens) + for (var key in this.tokens) + str = str.replace(":" + key, this.tokens[key]); + if (this.lastDraw !== str) { + this.stream.cursorTo(0); + this.stream.write(str); + this.stream.clearLine(1); + this.lastDraw = str; + } + }; + ProgressBar2.prototype.update = function(ratio, tokens) { + var goal = Math.floor(ratio * this.total); + var delta = goal - this.curr; + this.tick(delta, tokens); + }; + ProgressBar2.prototype.interrupt = function(message) { + this.stream.clearLine(); + this.stream.cursorTo(0); + this.stream.write(message); + this.stream.write("\n"); + this.stream.write(this.lastDraw); + }; + ProgressBar2.prototype.terminate = function() { + if (this.clear) { + if (this.stream.clearLine) { + this.stream.clearLine(); + this.stream.cursorTo(0); + } + } else { + this.stream.write("\n"); + } + }; + } +}); + +// ../testeranto/node_modules/progress/index.js +var require_progress = __commonJS({ + "../testeranto/node_modules/progress/index.js"(exports, module) { + init_cjs_shim(); + module.exports = require_node_progress(); + } +}); + +// node_modules/chai/index.mjs +init_cjs_shim(); +var import_index = __toESM(require_chai2(), 1); +var expect = import_index.default.expect; +var version = import_index.default.version; +var Assertion = import_index.default.Assertion; +var AssertionError = import_index.default.AssertionError; +var util = import_index.default.util; +var config = import_index.default.config; +var use = import_index.default.use; +var should = import_index.default.should; +var assert2 = import_index.default.assert; +var core = import_index.default.core; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/puppeteer-core.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/index.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/index-browser.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/api/api.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/cdp.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Binding.js +init_cjs_shim(); +var __addDisposableResource = function(env2, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env2.stack.push({ value, dispose, async }); + } else if (async) { + env2.stack.push({ async: true }); + } + return value; +}; +var __disposeResources = function(SuppressedError2) { + return function(env2) { + function fail(e) { + env2.error = env2.hasError ? new SuppressedError2(e, env2.error, "An error was suppressed during disposal.") : e; + env2.hasError = true; + } + var r, s = 0; + function next() { + while (r = env2.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env2.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env2.hasError ? Promise.reject(env2.error) : Promise.resolve(); + if (env2.hasError) + throw env2.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var Binding = class { + #name; + #fn; + #initSource; + constructor(name, fn, initSource) { + this.#name = name; + this.#fn = fn; + this.#initSource = initSource; + } + get name() { + return this.#name; + } + get initSource() { + return this.#initSource; + } + /** + * @param context - Context to run the binding in; the context should have + * the binding added to it beforehand. + * @param id - ID of the call. This should come from the CDP + * `onBindingCalled` response. + * @param args - Plain arguments from CDP. + */ + async run(context, id, args, isTrivial) { + const stack = new DisposableStack(); + try { + if (!isTrivial) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const handles = __addDisposableResource(env_1, await context.evaluateHandle((name, seq) => { + return globalThis[name].args.get(seq); + }, this.#name, id), false); + const properties = await handles.getProperties(); + for (const [index, handle] of properties) { + if (index in args) { + switch (handle.remoteObject().subtype) { + case "node": + args[+index] = handle; + break; + default: + stack.use(handle); + } + } else { + stack.use(handle); + } + } + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources(env_1); + } + } + await context.evaluate((name, seq, result) => { + const callbacks = globalThis[name].callbacks; + callbacks.get(seq).resolve(result); + callbacks.delete(seq); + }, this.#name, id, await this.#fn(...args)); + for (const arg of args) { + if (arg instanceof JSHandle) { + stack.use(arg); + } + } + } catch (error) { + if (isErrorLike(error)) { + await context.evaluate((name, seq, message, stack2) => { + const error2 = new Error(message); + error2.stack = stack2; + const callbacks = globalThis[name].callbacks; + callbacks.get(seq).reject(error2); + callbacks.delete(seq); + }, this.#name, id, error.message, error.stack).catch(debugError); + } else { + await context.evaluate((name, seq, error2) => { + const callbacks = globalThis[name].callbacks; + callbacks.get(seq).reject(error2); + callbacks.delete(seq); + }, this.#name, id, error).catch(debugError); + } + } + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Browser.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/BrowserContext.js +init_cjs_shim(); +var __addDisposableResource2 = function(env2, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env2.stack.push({ value, dispose, async }); + } else if (async) { + env2.stack.push({ async: true }); + } + return value; +}; +var __disposeResources2 = function(SuppressedError2) { + return function(env2) { + function fail(e) { + env2.error = env2.hasError ? new SuppressedError2(e, env2.error, "An error was suppressed during disposal.") : e; + env2.hasError = true; + } + var r, s = 0; + function next() { + while (r = env2.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env2.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env2.hasError ? Promise.reject(env2.error) : Promise.resolve(); + if (env2.hasError) + throw env2.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var CdpBrowserContext = class extends BrowserContext { + #connection; + #browser; + #id; + constructor(connection, browser, contextId) { + super(); + this.#connection = connection; + this.#browser = browser; + this.#id = contextId; + } + get id() { + return this.#id; + } + targets() { + return this.#browser.targets().filter((target) => { + return target.browserContext() === this; + }); + } + async pages() { + const pages = await Promise.all(this.targets().filter((target) => { + return target.type() === "page" || target.type() === "other" && this.#browser._getIsPageTargetCallback()?.(target); + }).map((target) => { + return target.page(); + })); + return pages.filter((page) => { + return !!page; + }); + } + async overridePermissions(origin, permissions) { + const protocolPermissions = permissions.map((permission) => { + const protocolPermission = WEB_PERMISSION_TO_PROTOCOL_PERMISSION.get(permission); + if (!protocolPermission) { + throw new Error("Unknown permission: " + permission); + } + return protocolPermission; + }); + await this.#connection.send("Browser.grantPermissions", { + origin, + browserContextId: this.#id || void 0, + permissions: protocolPermissions + }); + } + async clearPermissionOverrides() { + await this.#connection.send("Browser.resetPermissions", { + browserContextId: this.#id || void 0 + }); + } + async newPage() { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const _guard = __addDisposableResource2(env_1, await this.waitForScreenshotOperations(), false); + return await this.#browser._createPageInContext(this.#id); + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources2(env_1); + } + } + browser() { + return this.#browser; + } + async close() { + assert(this.#id, "Default BrowserContext cannot be closed!"); + await this.#browser._disposeContext(this.#id); + } + async setDownloadBehavior(downloadBehavior) { + await this.#connection.send("Browser.setDownloadBehavior", { + behavior: downloadBehavior.policy, + downloadPath: downloadBehavior.downloadPath, + browserContextId: this.#id + }); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/ChromeTargetManager.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Target.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/CDPSession.js +init_cjs_shim(); +var CdpCDPSession = class extends CDPSession { + #sessionId; + #targetType; + #callbacks = new CallbackRegistry(); + #connection; + #parentSessionId; + #target; + /** + * @internal + */ + constructor(connection, targetType, sessionId, parentSessionId) { + super(); + this.#connection = connection; + this.#targetType = targetType; + this.#sessionId = sessionId; + this.#parentSessionId = parentSessionId; + } + /** + * Sets the {@link CdpTarget} associated with the session instance. + * + * @internal + */ + _setTarget(target) { + this.#target = target; + } + /** + * Gets the {@link CdpTarget} associated with the session instance. + * + * @internal + */ + _target() { + assert(this.#target, "Target must exist"); + return this.#target; + } + connection() { + return this.#connection; + } + parentSession() { + if (!this.#parentSessionId) { + return this; + } + const parent = this.#connection?.session(this.#parentSessionId); + return parent ?? void 0; + } + send(method, params, options) { + if (!this.#connection) { + return Promise.reject(new TargetCloseError(`Protocol error (${method}): Session closed. Most likely the ${this.#targetType} has been closed.`)); + } + return this.#connection._rawSend(this.#callbacks, method, params, this.#sessionId, options); + } + /** + * @internal + */ + _onMessage(object) { + if (object.id) { + if (object.error) { + this.#callbacks.reject(object.id, createProtocolErrorMessage(object), object.error.message); + } else { + this.#callbacks.resolve(object.id, object.result); + } + } else { + assert(!object.id); + this.emit(object.method, object.params); + } + } + /** + * Detaches the cdpSession from the target. Once detached, the cdpSession object + * won't emit any events and can't be used to send messages. + */ + async detach() { + if (!this.#connection) { + throw new Error(`Session already detached. Most likely the ${this.#targetType} has been closed.`); + } + await this.#connection.send("Target.detachFromTarget", { + sessionId: this.#sessionId + }); + } + /** + * @internal + */ + _onClosed() { + this.#callbacks.clear(); + this.#connection = void 0; + this.emit(CDPSessionEvent.Disconnected, void 0); + } + /** + * Returns the session's id. + */ + id() { + return this.#sessionId; + } + /** + * @internal + */ + getPendingProtocolErrors() { + return this.#callbacks.getPendingProtocolErrors(); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Page.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/FileChooser.js +init_cjs_shim(); +var FileChooser = class { + #element; + #multiple; + #handled = false; + /** + * @internal + */ + constructor(element, event) { + this.#element = element; + this.#multiple = event.mode !== "selectSingle"; + } + /** + * Whether file chooser allow for + * {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#attr-multiple | multiple} + * file selection. + */ + isMultiple() { + return this.#multiple; + } + /** + * Accept the file chooser request with the given file paths. + * + * @remarks This will not validate whether the file paths exists. Also, if a + * path is relative, then it is resolved against the + * {@link https://nodejs.org/api/process.html#process_process_cwd | current working directory}. + * For locals script connecting to remote chrome environments, paths must be + * absolute. + */ + async accept(paths) { + assert(!this.#handled, "Cannot accept FileChooser which is already handled!"); + this.#handled = true; + await this.#element.uploadFile(...paths); + } + /** + * Closes the file chooser without selecting any files. + */ + async cancel() { + assert(!this.#handled, "Cannot cancel FileChooser which is already handled!"); + this.#handled = true; + await this.#element.evaluate((element) => { + element.dispatchEvent(new Event("cancel", { bubbles: true })); + }); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/NetworkManagerEvents.js +init_cjs_shim(); +var NetworkManagerEvent; +(function(NetworkManagerEvent2) { + NetworkManagerEvent2.Request = Symbol("NetworkManager.Request"); + NetworkManagerEvent2.RequestServedFromCache = Symbol("NetworkManager.RequestServedFromCache"); + NetworkManagerEvent2.Response = Symbol("NetworkManager.Response"); + NetworkManagerEvent2.RequestFailed = Symbol("NetworkManager.RequestFailed"); + NetworkManagerEvent2.RequestFinished = Symbol("NetworkManager.RequestFinished"); +})(NetworkManagerEvent || (NetworkManagerEvent = {})); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Connection.js +init_cjs_shim(); +var debugProtocolSend = debug("puppeteer:protocol:SEND \u25BA"); +var debugProtocolReceive = debug("puppeteer:protocol:RECV \u25C0"); +var Connection = class extends EventEmitter { + #url; + #transport; + #delay; + #timeout; + #sessions = /* @__PURE__ */ new Map(); + #closed = false; + #manuallyAttached = /* @__PURE__ */ new Set(); + #callbacks = new CallbackRegistry(); + constructor(url, transport, delay = 0, timeout2) { + super(); + this.#url = url; + this.#delay = delay; + this.#timeout = timeout2 ?? 18e4; + this.#transport = transport; + this.#transport.onmessage = this.onMessage.bind(this); + this.#transport.onclose = this.#onClose.bind(this); + } + static fromSession(session) { + return session.connection(); + } + /** + * @internal + */ + get delay() { + return this.#delay; + } + get timeout() { + return this.#timeout; + } + /** + * @internal + */ + get _closed() { + return this.#closed; + } + /** + * @internal + */ + get _sessions() { + return this.#sessions; + } + /** + * @param sessionId - The session id + * @returns The current CDP session if it exists + */ + session(sessionId) { + return this.#sessions.get(sessionId) || null; + } + url() { + return this.#url; + } + send(method, params, options) { + return this._rawSend(this.#callbacks, method, params, void 0, options); + } + /** + * @internal + */ + _rawSend(callbacks, method, params, sessionId, options) { + if (this.#closed) { + return Promise.reject(new Error("Protocol error: Connection closed.")); + } + return callbacks.create(method, options?.timeout ?? this.#timeout, (id) => { + const stringifiedMessage = JSON.stringify({ + method, + params, + id, + sessionId + }); + debugProtocolSend(stringifiedMessage); + this.#transport.send(stringifiedMessage); + }); + } + /** + * @internal + */ + async closeBrowser() { + await this.send("Browser.close"); + } + /** + * @internal + */ + async onMessage(message) { + if (this.#delay) { + await new Promise((r) => { + return setTimeout(r, this.#delay); + }); + } + debugProtocolReceive(message); + const object = JSON.parse(message); + if (object.method === "Target.attachedToTarget") { + const sessionId = object.params.sessionId; + const session = new CdpCDPSession(this, object.params.targetInfo.type, sessionId, object.sessionId); + this.#sessions.set(sessionId, session); + this.emit(CDPSessionEvent.SessionAttached, session); + const parentSession = this.#sessions.get(object.sessionId); + if (parentSession) { + parentSession.emit(CDPSessionEvent.SessionAttached, session); + } + } else if (object.method === "Target.detachedFromTarget") { + const session = this.#sessions.get(object.params.sessionId); + if (session) { + session._onClosed(); + this.#sessions.delete(object.params.sessionId); + this.emit(CDPSessionEvent.SessionDetached, session); + const parentSession = this.#sessions.get(object.sessionId); + if (parentSession) { + parentSession.emit(CDPSessionEvent.SessionDetached, session); + } + } + } + if (object.sessionId) { + const session = this.#sessions.get(object.sessionId); + if (session) { + session._onMessage(object); + } + } else if (object.id) { + if (object.error) { + this.#callbacks.reject(object.id, createProtocolErrorMessage(object), object.error.message); + } else { + this.#callbacks.resolve(object.id, object.result); + } + } else { + this.emit(object.method, object.params); + } + } + #onClose() { + if (this.#closed) { + return; + } + this.#closed = true; + this.#transport.onmessage = void 0; + this.#transport.onclose = void 0; + this.#callbacks.clear(); + for (const session of this.#sessions.values()) { + session._onClosed(); + } + this.#sessions.clear(); + this.emit(CDPSessionEvent.Disconnected, void 0); + } + dispose() { + this.#onClose(); + this.#transport.close(); + } + /** + * @internal + */ + isAutoAttached(targetId) { + return !this.#manuallyAttached.has(targetId); + } + /** + * @internal + */ + async _createSession(targetInfo, isAutoAttachEmulated = true) { + if (!isAutoAttachEmulated) { + this.#manuallyAttached.add(targetInfo.targetId); + } + const { sessionId } = await this.send("Target.attachToTarget", { + targetId: targetInfo.targetId, + flatten: true + }); + this.#manuallyAttached.delete(targetInfo.targetId); + const session = this.#sessions.get(sessionId); + if (!session) { + throw new Error("CDPSession creation failed."); + } + return session; + } + /** + * @param targetInfo - The target info + * @returns The CDP session that is created + */ + async createSession(targetInfo) { + return await this._createSession(targetInfo, false); + } + /** + * @internal + */ + getPendingProtocolErrors() { + const result = []; + result.push(...this.#callbacks.getPendingProtocolErrors()); + for (const session of this.#sessions.values()) { + result.push(...session.getPendingProtocolErrors()); + } + return result; + } +}; +function isTargetClosedError(error) { + return error instanceof TargetCloseError; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Dialog.js +init_cjs_shim(); +var CdpDialog = class extends Dialog { + #client; + constructor(client, type, message, defaultValue = "") { + super(type, message, defaultValue); + this.#client = client; + } + async handle(options) { + await this.#client.send("Page.handleJavaScriptDialog", { + accept: options.accept, + promptText: options.text + }); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/FirefoxTargetManager.js +init_cjs_shim(); +var FirefoxTargetManager = class extends EventEmitter { + #connection; + /** + * Keeps track of the following events: 'Target.targetCreated', + * 'Target.targetDestroyed'. + * + * A target becomes discovered when 'Target.targetCreated' is received. + * A target is removed from this map once 'Target.targetDestroyed' is + * received. + * + * `targetFilterCallback` has no effect on this map. + */ + #discoveredTargetsByTargetId = /* @__PURE__ */ new Map(); + /** + * Keeps track of targets that were created via 'Target.targetCreated' + * and which one are not filtered out by `targetFilterCallback`. + * + * The target is removed from here once it's been destroyed. + */ + #availableTargetsByTargetId = /* @__PURE__ */ new Map(); + /** + * Tracks which sessions attach to which target. + */ + #availableTargetsBySessionId = /* @__PURE__ */ new Map(); + #targetFilterCallback; + #targetFactory; + #attachedToTargetListenersBySession = /* @__PURE__ */ new WeakMap(); + #initializeDeferred = Deferred.create(); + #targetsIdsForInit = /* @__PURE__ */ new Set(); + constructor(connection, targetFactory, targetFilterCallback) { + super(); + this.#connection = connection; + this.#targetFilterCallback = targetFilterCallback; + this.#targetFactory = targetFactory; + this.#connection.on("Target.targetCreated", this.#onTargetCreated); + this.#connection.on("Target.targetDestroyed", this.#onTargetDestroyed); + this.#connection.on(CDPSessionEvent.SessionDetached, this.#onSessionDetached); + this.setupAttachmentListeners(this.#connection); + } + setupAttachmentListeners(session) { + const listener = (event) => { + return this.#onAttachedToTarget(session, event); + }; + assert(!this.#attachedToTargetListenersBySession.has(session)); + this.#attachedToTargetListenersBySession.set(session, listener); + session.on("Target.attachedToTarget", listener); + } + #onSessionDetached = (session) => { + this.removeSessionListeners(session); + this.#availableTargetsBySessionId.delete(session.id()); + }; + removeSessionListeners(session) { + if (this.#attachedToTargetListenersBySession.has(session)) { + session.off("Target.attachedToTarget", this.#attachedToTargetListenersBySession.get(session)); + this.#attachedToTargetListenersBySession.delete(session); + } + } + getAvailableTargets() { + return this.#availableTargetsByTargetId; + } + getChildTargets(_target) { + return /* @__PURE__ */ new Set(); + } + dispose() { + this.#connection.off("Target.targetCreated", this.#onTargetCreated); + this.#connection.off("Target.targetDestroyed", this.#onTargetDestroyed); + } + async initialize() { + await this.#connection.send("Target.setDiscoverTargets", { + discover: true, + filter: [{}] + }); + this.#targetsIdsForInit = new Set(this.#discoveredTargetsByTargetId.keys()); + await this.#initializeDeferred.valueOrThrow(); + } + #onTargetCreated = async (event) => { + if (this.#discoveredTargetsByTargetId.has(event.targetInfo.targetId)) { + return; + } + this.#discoveredTargetsByTargetId.set(event.targetInfo.targetId, event.targetInfo); + if (event.targetInfo.type === "browser" && event.targetInfo.attached) { + const target2 = this.#targetFactory(event.targetInfo, void 0); + target2._initialize(); + this.#availableTargetsByTargetId.set(event.targetInfo.targetId, target2); + this.#finishInitializationIfReady(target2._targetId); + return; + } + const target = this.#targetFactory(event.targetInfo, void 0); + if (this.#targetFilterCallback && !this.#targetFilterCallback(target)) { + this.#finishInitializationIfReady(event.targetInfo.targetId); + return; + } + target._initialize(); + this.#availableTargetsByTargetId.set(event.targetInfo.targetId, target); + this.emit("targetAvailable", target); + this.#finishInitializationIfReady(target._targetId); + }; + #onTargetDestroyed = (event) => { + this.#discoveredTargetsByTargetId.delete(event.targetId); + this.#finishInitializationIfReady(event.targetId); + const target = this.#availableTargetsByTargetId.get(event.targetId); + if (target) { + this.emit("targetGone", target); + this.#availableTargetsByTargetId.delete(event.targetId); + } + }; + #onAttachedToTarget = async (parentSession, event) => { + const targetInfo = event.targetInfo; + const session = this.#connection.session(event.sessionId); + if (!session) { + throw new Error(`Session ${event.sessionId} was not created.`); + } + const target = this.#availableTargetsByTargetId.get(targetInfo.targetId); + assert(target, `Target ${targetInfo.targetId} is missing`); + session._setTarget(target); + this.setupAttachmentListeners(session); + this.#availableTargetsBySessionId.set(session.id(), this.#availableTargetsByTargetId.get(targetInfo.targetId)); + parentSession.emit(CDPSessionEvent.Ready, session); + }; + #finishInitializationIfReady(targetId) { + this.#targetsIdsForInit.delete(targetId); + if (this.#targetsIdsForInit.size === 0) { + this.#initializeDeferred.resolve(); + } + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/FrameManager.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/CdpPreloadScript.js +init_cjs_shim(); +var CdpPreloadScript = class { + /** + * This is the ID of the preload script returned by + * Page.addScriptToEvaluateOnNewDocument in the main frame. + * + * Sub-frames would get a different CDP ID because + * addScriptToEvaluateOnNewDocument is called for each subframe. But + * users only see this ID and subframe IDs are internal to Puppeteer. + */ + #id; + #source; + #frameToId = /* @__PURE__ */ new WeakMap(); + constructor(mainFrame, id, source) { + this.#id = id; + this.#source = source; + this.#frameToId.set(mainFrame, id); + } + get id() { + return this.#id; + } + get source() { + return this.#source; + } + getIdForFrame(frame) { + return this.#frameToId.get(frame); + } + setIdForFrame(frame, identifier) { + this.#frameToId.set(frame, identifier); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/DeviceRequestPrompt.js +init_cjs_shim(); +var DeviceRequestPromptDevice = class { + /** + * Device id during a prompt. + */ + id; + /** + * Device name as it appears in a prompt. + */ + name; + /** + * @internal + */ + constructor(id, name) { + this.id = id; + this.name = name; + } +}; +var DeviceRequestPrompt = class { + #client; + #timeoutSettings; + #id; + #handled = false; + #updateDevicesHandle = this.#updateDevices.bind(this); + #waitForDevicePromises = /* @__PURE__ */ new Set(); + /** + * Current list of selectable devices. + */ + devices = []; + /** + * @internal + */ + constructor(client, timeoutSettings, firstEvent) { + this.#client = client; + this.#timeoutSettings = timeoutSettings; + this.#id = firstEvent.id; + this.#client.on("DeviceAccess.deviceRequestPrompted", this.#updateDevicesHandle); + this.#client.on("Target.detachedFromTarget", () => { + this.#client = null; + }); + this.#updateDevices(firstEvent); + } + #updateDevices(event) { + if (event.id !== this.#id) { + return; + } + for (const rawDevice of event.devices) { + if (this.devices.some((device) => { + return device.id === rawDevice.id; + })) { + continue; + } + const newDevice = new DeviceRequestPromptDevice(rawDevice.id, rawDevice.name); + this.devices.push(newDevice); + for (const waitForDevicePromise of this.#waitForDevicePromises) { + if (waitForDevicePromise.filter(newDevice)) { + waitForDevicePromise.promise.resolve(newDevice); + } + } + } + } + /** + * Resolve to the first device in the prompt matching a filter. + */ + async waitForDevice(filter2, options = {}) { + for (const device of this.devices) { + if (filter2(device)) { + return device; + } + } + const { timeout: timeout2 = this.#timeoutSettings.timeout() } = options; + const deferred = Deferred.create({ + message: `Waiting for \`DeviceRequestPromptDevice\` failed: ${timeout2}ms exceeded`, + timeout: timeout2 + }); + if (options.signal) { + options.signal.addEventListener("abort", () => { + deferred.reject(options.signal?.reason); + }, { once: true }); + } + const handle = { filter: filter2, promise: deferred }; + this.#waitForDevicePromises.add(handle); + try { + return await deferred.valueOrThrow(); + } finally { + this.#waitForDevicePromises.delete(handle); + } + } + /** + * Select a device in the prompt's list. + */ + async select(device) { + assert(this.#client !== null, "Cannot select device through detached session!"); + assert(this.devices.includes(device), "Cannot select unknown device!"); + assert(!this.#handled, "Cannot select DeviceRequestPrompt which is already handled!"); + this.#client.off("DeviceAccess.deviceRequestPrompted", this.#updateDevicesHandle); + this.#handled = true; + return await this.#client.send("DeviceAccess.selectPrompt", { + id: this.#id, + deviceId: device.id + }); + } + /** + * Cancel the prompt. + */ + async cancel() { + assert(this.#client !== null, "Cannot cancel prompt through detached session!"); + assert(!this.#handled, "Cannot cancel DeviceRequestPrompt which is already handled!"); + this.#client.off("DeviceAccess.deviceRequestPrompted", this.#updateDevicesHandle); + this.#handled = true; + return await this.#client.send("DeviceAccess.cancelPrompt", { id: this.#id }); + } +}; +var DeviceRequestPromptManager = class { + #client; + #timeoutSettings; + #deviceRequestPrompDeferreds = /* @__PURE__ */ new Set(); + /** + * @internal + */ + constructor(client, timeoutSettings) { + this.#client = client; + this.#timeoutSettings = timeoutSettings; + this.#client.on("DeviceAccess.deviceRequestPrompted", (event) => { + this.#onDeviceRequestPrompted(event); + }); + this.#client.on("Target.detachedFromTarget", () => { + this.#client = null; + }); + } + /** + * Wait for device prompt created by an action like calling WebBluetooth's + * requestDevice. + */ + async waitForDevicePrompt(options = {}) { + assert(this.#client !== null, "Cannot wait for device prompt through detached session!"); + const needsEnable = this.#deviceRequestPrompDeferreds.size === 0; + let enablePromise; + if (needsEnable) { + enablePromise = this.#client.send("DeviceAccess.enable"); + } + const { timeout: timeout2 = this.#timeoutSettings.timeout() } = options; + const deferred = Deferred.create({ + message: `Waiting for \`DeviceRequestPrompt\` failed: ${timeout2}ms exceeded`, + timeout: timeout2 + }); + if (options.signal) { + options.signal.addEventListener("abort", () => { + deferred.reject(options.signal?.reason); + }, { once: true }); + } + this.#deviceRequestPrompDeferreds.add(deferred); + try { + const [result] = await Promise.all([ + deferred.valueOrThrow(), + enablePromise + ]); + return result; + } finally { + this.#deviceRequestPrompDeferreds.delete(deferred); + } + } + /** + * @internal + */ + #onDeviceRequestPrompted(event) { + if (!this.#deviceRequestPrompDeferreds.size) { + return; + } + assert(this.#client !== null); + const devicePrompt = new DeviceRequestPrompt(this.#client, this.#timeoutSettings, event); + for (const promise of this.#deviceRequestPrompDeferreds) { + promise.resolve(devicePrompt); + } + this.#deviceRequestPrompDeferreds.clear(); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/ExecutionContext.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/ElementHandle.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/JSHandle.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/utils.js +init_cjs_shim(); +function createEvaluationError(details) { + let name; + let message; + if (!details.exception) { + name = "Error"; + message = details.text; + } else if ((details.exception.type !== "object" || details.exception.subtype !== "error") && !details.exception.objectId) { + return valueFromRemoteObject(details.exception); + } else { + const detail = getErrorDetails(details); + name = detail.name; + message = detail.message; + } + const messageHeight = message.split("\n").length; + const error = new Error(message); + error.name = name; + const stackLines = error.stack.split("\n"); + const messageLines = stackLines.splice(0, messageHeight); + stackLines.shift(); + if (details.stackTrace && stackLines.length < Error.stackTraceLimit) { + for (const frame of details.stackTrace.callFrames.reverse()) { + if (PuppeteerURL.isPuppeteerURL(frame.url) && frame.url !== PuppeteerURL.INTERNAL_URL) { + const url = PuppeteerURL.parse(frame.url); + stackLines.unshift(` at ${frame.functionName || url.functionName} (${url.functionName} at ${url.siteString}, :${frame.lineNumber}:${frame.columnNumber})`); + } else { + stackLines.push(` at ${frame.functionName || ""} (${frame.url}:${frame.lineNumber}:${frame.columnNumber})`); + } + if (stackLines.length >= Error.stackTraceLimit) { + break; + } + } + } + error.stack = [...messageLines, ...stackLines].join("\n"); + return error; +} +var getErrorDetails = (details) => { + let name = ""; + let message; + const lines = details.exception?.description?.split("\n at ") ?? []; + const size = Math.min(details.stackTrace?.callFrames.length ?? 0, lines.length - 1); + lines.splice(-size, size); + if (details.exception?.className) { + name = details.exception.className; + } + message = lines.join("\n"); + if (name && message.startsWith(`${name}: `)) { + message = message.slice(name.length + 2); + } + return { message, name }; +}; +function createClientError(details) { + let name; + let message; + if (!details.exception) { + name = "Error"; + message = details.text; + } else if ((details.exception.type !== "object" || details.exception.subtype !== "error") && !details.exception.objectId) { + return valueFromRemoteObject(details.exception); + } else { + const detail = getErrorDetails(details); + name = detail.name; + message = detail.message; + } + const error = new Error(message); + error.name = name; + const messageHeight = error.message.split("\n").length; + const messageLines = error.stack.split("\n").splice(0, messageHeight); + const stackLines = []; + if (details.stackTrace) { + for (const frame of details.stackTrace.callFrames) { + stackLines.push(` at ${frame.functionName || ""} (${frame.url}:${frame.lineNumber + 1}:${frame.columnNumber + 1})`); + if (stackLines.length >= Error.stackTraceLimit) { + break; + } + } + } + error.stack = [...messageLines, ...stackLines].join("\n"); + return error; +} +function valueFromRemoteObject(remoteObject) { + assert(!remoteObject.objectId, "Cannot extract value when objectId is given"); + if (remoteObject.unserializableValue) { + if (remoteObject.type === "bigint") { + return BigInt(remoteObject.unserializableValue.replace("n", "")); + } + switch (remoteObject.unserializableValue) { + case "-0": + return -0; + case "NaN": + return NaN; + case "Infinity": + return Infinity; + case "-Infinity": + return -Infinity; + default: + throw new Error("Unsupported unserializable value: " + remoteObject.unserializableValue); + } + } + return remoteObject.value; +} +function addPageBinding(type, name, prefix) { + if (globalThis[name]) { + return; + } + Object.assign(globalThis, { + [name](...args) { + const callPuppeteer = globalThis[name]; + callPuppeteer.args ??= /* @__PURE__ */ new Map(); + callPuppeteer.callbacks ??= /* @__PURE__ */ new Map(); + const seq = (callPuppeteer.lastSeq ?? 0) + 1; + callPuppeteer.lastSeq = seq; + callPuppeteer.args.set(seq, args); + globalThis[prefix + name](JSON.stringify({ + type, + name, + seq, + args, + isTrivial: !args.some((value) => { + return value instanceof Node; + }) + })); + return new Promise((resolve5, reject) => { + callPuppeteer.callbacks.set(seq, { + resolve(value) { + callPuppeteer.args.delete(seq); + resolve5(value); + }, + reject(value) { + callPuppeteer.args.delete(seq); + reject(value); + } + }); + }); + } + }); +} +var CDP_BINDING_PREFIX = "puppeteer_"; +function pageBindingInitString(type, name) { + return evaluationString(addPageBinding, type, name, CDP_BINDING_PREFIX); +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/JSHandle.js +var CdpJSHandle = class extends JSHandle { + #disposed = false; + #remoteObject; + #world; + constructor(world, remoteObject) { + super(); + this.#world = world; + this.#remoteObject = remoteObject; + } + get disposed() { + return this.#disposed; + } + get realm() { + return this.#world; + } + get client() { + return this.realm.environment.client; + } + async jsonValue() { + if (!this.#remoteObject.objectId) { + return valueFromRemoteObject(this.#remoteObject); + } + const value = await this.evaluate((object) => { + return object; + }); + if (value === void 0) { + throw new Error("Could not serialize referenced object"); + } + return value; + } + /** + * Either `null` or the handle itself if the handle is an + * instance of {@link ElementHandle}. + */ + asElement() { + return null; + } + async dispose() { + if (this.#disposed) { + return; + } + this.#disposed = true; + await releaseObject(this.client, this.#remoteObject); + } + toString() { + if (!this.#remoteObject.objectId) { + return "JSHandle:" + valueFromRemoteObject(this.#remoteObject); + } + const type = this.#remoteObject.subtype || this.#remoteObject.type; + return "JSHandle@" + type; + } + get id() { + return this.#remoteObject.objectId; + } + remoteObject() { + return this.#remoteObject; + } + async getProperties() { + const response = await this.client.send("Runtime.getProperties", { + objectId: this.#remoteObject.objectId, + ownProperties: true + }); + const result = /* @__PURE__ */ new Map(); + for (const property of response.result) { + if (!property.enumerable || !property.value) { + continue; + } + result.set(property.name, this.#world.createCdpHandle(property.value)); + } + return result; + } +}; +async function releaseObject(client, remoteObject) { + if (!remoteObject.objectId) { + return; + } + await client.send("Runtime.releaseObject", { objectId: remoteObject.objectId }).catch((error) => { + debugError(error); + }); +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/ElementHandle.js +var __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 = 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 NON_ELEMENT_NODE_ROLES = /* @__PURE__ */ new Set(["StaticText", "InlineTextBox"]); +var CdpElementHandle = (() => { + let _classSuper = ElementHandle; + let _instanceExtraInitializers = []; + let _contentFrame_decorators; + let _scrollIntoView_decorators; + let _uploadFile_decorators; + let _autofill_decorators; + return class CdpElementHandle extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + _contentFrame_decorators = [throwIfDisposed()]; + _scrollIntoView_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _uploadFile_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _autofill_decorators = [throwIfDisposed()]; + __esDecorate(this, null, _contentFrame_decorators, { kind: "method", name: "contentFrame", static: false, private: false, access: { has: (obj) => "contentFrame" in obj, get: (obj) => obj.contentFrame }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate(this, null, _scrollIntoView_decorators, { kind: "method", name: "scrollIntoView", static: false, private: false, access: { has: (obj) => "scrollIntoView" in obj, get: (obj) => obj.scrollIntoView }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate(this, null, _uploadFile_decorators, { kind: "method", name: "uploadFile", static: false, private: false, access: { has: (obj) => "uploadFile" in obj, get: (obj) => obj.uploadFile }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate(this, null, _autofill_decorators, { kind: "method", name: "autofill", static: false, private: false, access: { has: (obj) => "autofill" in obj, get: (obj) => obj.autofill }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + constructor(world, remoteObject) { + super(new CdpJSHandle(world, remoteObject)); + __runInitializers(this, _instanceExtraInitializers); + } + get realm() { + return this.handle.realm; + } + get client() { + return this.handle.client; + } + remoteObject() { + return this.handle.remoteObject(); + } + get #frameManager() { + return this.frame._frameManager; + } + get frame() { + return this.realm.environment; + } + async contentFrame() { + const nodeInfo = await this.client.send("DOM.describeNode", { + objectId: this.id + }); + if (typeof nodeInfo.node.frameId !== "string") { + return null; + } + return this.#frameManager.frame(nodeInfo.node.frameId); + } + async scrollIntoView() { + await this.assertConnectedElement(); + try { + await this.client.send("DOM.scrollIntoViewIfNeeded", { + objectId: this.id + }); + } catch (error) { + debugError(error); + await super.scrollIntoView(); + } + } + async uploadFile(...files) { + const isMultiple = await this.evaluate((element) => { + return element.multiple; + }); + assert(files.length <= 1 || isMultiple, "Multiple file uploads only work with "); + const path10 = environment.value.path; + if (path10) { + files = files.map((filePath) => { + if (path10.win32.isAbsolute(filePath) || path10.posix.isAbsolute(filePath)) { + return filePath; + } else { + return path10.resolve(filePath); + } + }); + } + if (files.length === 0) { + await this.evaluate((element) => { + element.files = new DataTransfer().files; + element.dispatchEvent(new Event("input", { bubbles: true, composed: true })); + element.dispatchEvent(new Event("change", { bubbles: true })); + }); + return; + } + const { node: { backendNodeId } } = await this.client.send("DOM.describeNode", { + objectId: this.id + }); + await this.client.send("DOM.setFileInputFiles", { + objectId: this.id, + files, + backendNodeId + }); + } + async autofill(data) { + const nodeInfo = await this.client.send("DOM.describeNode", { + objectId: this.handle.id + }); + const fieldId = nodeInfo.node.backendNodeId; + const frameId = this.frame._id; + await this.client.send("Autofill.trigger", { + fieldId, + frameId, + card: data.creditCard + }); + } + async *queryAXTree(name, role) { + const { nodes } = await this.client.send("Accessibility.queryAXTree", { + objectId: this.id, + accessibleName: name, + role + }); + const results = nodes.filter((node) => { + if (node.ignored) { + return false; + } + if (!node.role) { + return false; + } + if (NON_ELEMENT_NODE_ROLES.has(node.role.value)) { + return false; + } + return true; + }); + return yield* AsyncIterableUtil.map(results, (node) => { + return this.realm.adoptBackendNode(node.backendDOMNodeId); + }); + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/ExecutionContext.js +var __addDisposableResource3 = function(env2, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env2.stack.push({ value, dispose, async }); + } else if (async) { + env2.stack.push({ async: true }); + } + return value; +}; +var __disposeResources3 = function(SuppressedError2) { + return function(env2) { + function fail(e) { + env2.error = env2.hasError ? new SuppressedError2(e, env2.error, "An error was suppressed during disposal.") : e; + env2.hasError = true; + } + var r, s = 0; + function next() { + while (r = env2.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env2.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env2.hasError ? Promise.reject(env2.error) : Promise.resolve(); + if (env2.hasError) + throw env2.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var ariaQuerySelectorBinding = new Binding("__ariaQuerySelector", ARIAQueryHandler.queryOne, ""); +var ariaQuerySelectorAllBinding = new Binding("__ariaQuerySelectorAll", async (element, selector) => { + const results = ARIAQueryHandler.queryAll(element, selector); + return await element.realm.evaluateHandle((...elements) => { + return elements; + }, ...await AsyncIterableUtil.collect(results)); +}, ""); +var ExecutionContext = class extends EventEmitter { + #client; + #world; + #id; + #name; + #disposables = new DisposableStack(); + constructor(client, contextPayload, world) { + super(); + this.#client = client; + this.#world = world; + this.#id = contextPayload.id; + if (contextPayload.name) { + this.#name = contextPayload.name; + } + const clientEmitter = this.#disposables.use(new EventEmitter(this.#client)); + clientEmitter.on("Runtime.bindingCalled", this.#onBindingCalled.bind(this)); + clientEmitter.on("Runtime.executionContextDestroyed", async (event) => { + if (event.executionContextId === this.#id) { + this[disposeSymbol](); + } + }); + clientEmitter.on("Runtime.executionContextsCleared", async () => { + this[disposeSymbol](); + }); + clientEmitter.on("Runtime.consoleAPICalled", this.#onConsoleAPI.bind(this)); + clientEmitter.on(CDPSessionEvent.Disconnected, () => { + this[disposeSymbol](); + }); + } + // Contains mapping from functions that should be bound to Puppeteer functions. + #bindings = /* @__PURE__ */ new Map(); + // If multiple waitFor are set up asynchronously, we need to wait for the + // first one to set up the binding in the page before running the others. + #mutex = new Mutex(); + async #addBinding(binding) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + if (this.#bindings.has(binding.name)) { + return; + } + const _ = __addDisposableResource3(env_1, await this.#mutex.acquire(), false); + try { + await this.#client.send("Runtime.addBinding", this.#name ? { + name: CDP_BINDING_PREFIX + binding.name, + executionContextName: this.#name + } : { + name: CDP_BINDING_PREFIX + binding.name, + executionContextId: this.#id + }); + await this.evaluate(addPageBinding, "internal", binding.name, CDP_BINDING_PREFIX); + this.#bindings.set(binding.name, binding); + } catch (error) { + if (error instanceof Error) { + if (error.message.includes("Execution context was destroyed")) { + return; + } + if (error.message.includes("Cannot find context with specified id")) { + return; + } + } + debugError(error); + } + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources3(env_1); + } + } + async #onBindingCalled(event) { + if (event.executionContextId !== this.#id) { + return; + } + let payload; + try { + payload = JSON.parse(event.payload); + } catch { + return; + } + const { type, name, seq, args, isTrivial } = payload; + if (type !== "internal") { + this.emit("bindingcalled", event); + return; + } + if (!this.#bindings.has(name)) { + this.emit("bindingcalled", event); + return; + } + try { + const binding = this.#bindings.get(name); + await binding?.run(this, seq, args, isTrivial); + } catch (err) { + debugError(err); + } + } + get id() { + return this.#id; + } + #onConsoleAPI(event) { + if (event.executionContextId !== this.#id) { + return; + } + this.emit("consoleapicalled", event); + } + #bindingsInstalled = false; + #puppeteerUtil; + get puppeteerUtil() { + let promise = Promise.resolve(); + if (!this.#bindingsInstalled) { + promise = Promise.all([ + this.#addBindingWithoutThrowing(ariaQuerySelectorBinding), + this.#addBindingWithoutThrowing(ariaQuerySelectorAllBinding) + ]); + this.#bindingsInstalled = true; + } + scriptInjector.inject((script) => { + if (this.#puppeteerUtil) { + void this.#puppeteerUtil.then((handle) => { + void handle.dispose(); + }); + } + this.#puppeteerUtil = promise.then(() => { + return this.evaluateHandle(script); + }); + }, !this.#puppeteerUtil); + return this.#puppeteerUtil; + } + async #addBindingWithoutThrowing(binding) { + try { + await this.#addBinding(binding); + } catch (err) { + debugError(err); + } + } + /** + * Evaluates the given function. + * + * @example + * + * ```ts + * const executionContext = await page.mainFrame().executionContext(); + * const result = await executionContext.evaluate(() => Promise.resolve(8 * 7))* ; + * console.log(result); // prints "56" + * ``` + * + * @example + * A string can also be passed in instead of a function: + * + * ```ts + * console.log(await executionContext.evaluate('1 + 2')); // prints "3" + * ``` + * + * @example + * Handles can also be passed as `args`. They resolve to their referenced object: + * + * ```ts + * const oneHandle = await executionContext.evaluateHandle(() => 1); + * const twoHandle = await executionContext.evaluateHandle(() => 2); + * const result = await executionContext.evaluate( + * (a, b) => a + b, + * oneHandle, + * twoHandle, + * ); + * await oneHandle.dispose(); + * await twoHandle.dispose(); + * console.log(result); // prints '3'. + * ``` + * + * @param pageFunction - The function to evaluate. + * @param args - Additional arguments to pass into the function. + * @returns The result of evaluating the function. If the result is an object, + * a vanilla object containing the serializable properties of the result is + * returned. + */ + async evaluate(pageFunction, ...args) { + return await this.#evaluate(true, pageFunction, ...args); + } + /** + * Evaluates the given function. + * + * Unlike {@link ExecutionContext.evaluate | evaluate}, this method returns a + * handle to the result of the function. + * + * This method may be better suited if the object cannot be serialized (e.g. + * `Map`) and requires further manipulation. + * + * @example + * + * ```ts + * const context = await page.mainFrame().executionContext(); + * const handle: JSHandle = await context.evaluateHandle( + * () => Promise.resolve(self), + * ); + * ``` + * + * @example + * A string can also be passed in instead of a function. + * + * ```ts + * const handle: JSHandle = await context.evaluateHandle('1 + 2'); + * ``` + * + * @example + * Handles can also be passed as `args`. They resolve to their referenced object: + * + * ```ts + * const bodyHandle: ElementHandle = + * await context.evaluateHandle(() => { + * return document.body; + * }); + * const stringHandle: JSHandle = await context.evaluateHandle( + * body => body.innerHTML, + * body, + * ); + * console.log(await stringHandle.jsonValue()); // prints body's innerHTML + * // Always dispose your garbage! :) + * await bodyHandle.dispose(); + * await stringHandle.dispose(); + * ``` + * + * @param pageFunction - The function to evaluate. + * @param args - Additional arguments to pass into the function. + * @returns A {@link JSHandle | handle} to the result of evaluating the + * function. If the result is a `Node`, then this will return an + * {@link ElementHandle | element handle}. + */ + async evaluateHandle(pageFunction, ...args) { + return await this.#evaluate(false, pageFunction, ...args); + } + async #evaluate(returnByValue, pageFunction, ...args) { + const sourceUrlComment = getSourceUrlComment(getSourcePuppeteerURLIfAvailable(pageFunction)?.toString() ?? PuppeteerURL.INTERNAL_URL); + if (isString(pageFunction)) { + const contextId = this.#id; + const expression = pageFunction; + const expressionWithSourceUrl = SOURCE_URL_REGEX.test(expression) ? expression : `${expression} +${sourceUrlComment} +`; + const { exceptionDetails: exceptionDetails2, result: remoteObject2 } = await this.#client.send("Runtime.evaluate", { + expression: expressionWithSourceUrl, + contextId, + returnByValue, + awaitPromise: true, + userGesture: true + }).catch(rewriteError); + if (exceptionDetails2) { + throw createEvaluationError(exceptionDetails2); + } + return returnByValue ? valueFromRemoteObject(remoteObject2) : this.#world.createCdpHandle(remoteObject2); + } + const functionDeclaration = stringifyFunction(pageFunction); + const functionDeclarationWithSourceUrl = SOURCE_URL_REGEX.test(functionDeclaration) ? functionDeclaration : `${functionDeclaration} +${sourceUrlComment} +`; + let callFunctionOnPromise; + try { + callFunctionOnPromise = this.#client.send("Runtime.callFunctionOn", { + functionDeclaration: functionDeclarationWithSourceUrl, + executionContextId: this.#id, + // LazyArgs are used only internally and should not affect the order + // evaluate calls for the public APIs. + arguments: args.some((arg) => { + return arg instanceof LazyArg; + }) ? await Promise.all(args.map((arg) => { + return convertArgumentAsync(this, arg); + })) : args.map((arg) => { + return convertArgument(this, arg); + }), + returnByValue, + awaitPromise: true, + userGesture: true + }); + } catch (error) { + if (error instanceof TypeError && error.message.startsWith("Converting circular structure to JSON")) { + error.message += " Recursive objects are not allowed."; + } + throw error; + } + const { exceptionDetails, result: remoteObject } = await callFunctionOnPromise.catch(rewriteError); + if (exceptionDetails) { + throw createEvaluationError(exceptionDetails); + } + return returnByValue ? valueFromRemoteObject(remoteObject) : this.#world.createCdpHandle(remoteObject); + async function convertArgumentAsync(context, arg) { + if (arg instanceof LazyArg) { + arg = await arg.get(context); + } + return convertArgument(context, arg); + } + function convertArgument(context, arg) { + if (typeof arg === "bigint") { + return { unserializableValue: `${arg.toString()}n` }; + } + if (Object.is(arg, -0)) { + return { unserializableValue: "-0" }; + } + if (Object.is(arg, Infinity)) { + return { unserializableValue: "Infinity" }; + } + if (Object.is(arg, -Infinity)) { + return { unserializableValue: "-Infinity" }; + } + if (Object.is(arg, NaN)) { + return { unserializableValue: "NaN" }; + } + const objectHandle = arg && (arg instanceof CdpJSHandle || arg instanceof CdpElementHandle) ? arg : null; + if (objectHandle) { + if (objectHandle.realm !== context.#world) { + throw new Error("JSHandles can be evaluated only in the context they were created!"); + } + if (objectHandle.disposed) { + throw new Error("JSHandle is disposed!"); + } + if (objectHandle.remoteObject().unserializableValue) { + return { + unserializableValue: objectHandle.remoteObject().unserializableValue + }; + } + if (!objectHandle.remoteObject().objectId) { + return { value: objectHandle.remoteObject().value }; + } + return { objectId: objectHandle.remoteObject().objectId }; + } + return { value: arg }; + } + } + [disposeSymbol]() { + this.#disposables.dispose(); + this.emit("disposed", void 0); + } +}; +var rewriteError = (error) => { + if (error.message.includes("Object reference chain is too long")) { + return { result: { type: "undefined" } }; + } + if (error.message.includes("Object couldn't be returned by value")) { + return { result: { type: "undefined" } }; + } + if (error.message.endsWith("Cannot find context with specified id") || error.message.endsWith("Inspected target navigated or closed")) { + throw new Error("Execution context was destroyed, most likely because of a navigation."); + } + throw error; +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Frame.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/FrameManagerEvents.js +init_cjs_shim(); +var FrameManagerEvent; +(function(FrameManagerEvent2) { + FrameManagerEvent2.FrameAttached = Symbol("FrameManager.FrameAttached"); + FrameManagerEvent2.FrameNavigated = Symbol("FrameManager.FrameNavigated"); + FrameManagerEvent2.FrameDetached = Symbol("FrameManager.FrameDetached"); + FrameManagerEvent2.FrameSwapped = Symbol("FrameManager.FrameSwapped"); + FrameManagerEvent2.LifecycleEvent = Symbol("FrameManager.LifecycleEvent"); + FrameManagerEvent2.FrameNavigatedWithinDocument = Symbol("FrameManager.FrameNavigatedWithinDocument"); + FrameManagerEvent2.ConsoleApiCalled = Symbol("FrameManager.ConsoleApiCalled"); + FrameManagerEvent2.BindingCalled = Symbol("FrameManager.BindingCalled"); +})(FrameManagerEvent || (FrameManagerEvent = {})); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/IsolatedWorld.js +init_cjs_shim(); +var IsolatedWorld = class extends Realm { + #context; + #emitter = new EventEmitter(); + #frameOrWorker; + constructor(frameOrWorker, timeoutSettings) { + super(timeoutSettings); + this.#frameOrWorker = frameOrWorker; + } + get environment() { + return this.#frameOrWorker; + } + get client() { + return this.#frameOrWorker.client; + } + get emitter() { + return this.#emitter; + } + setContext(context) { + this.#context?.[disposeSymbol](); + context.once("disposed", this.#onContextDisposed.bind(this)); + context.on("consoleapicalled", this.#onContextConsoleApiCalled.bind(this)); + context.on("bindingcalled", this.#onContextBindingCalled.bind(this)); + this.#context = context; + this.#emitter.emit("context", context); + void this.taskManager.rerunAll(); + } + #onContextDisposed() { + this.#context = void 0; + if ("clearDocumentHandle" in this.#frameOrWorker) { + this.#frameOrWorker.clearDocumentHandle(); + } + } + #onContextConsoleApiCalled(event) { + this.#emitter.emit("consoleapicalled", event); + } + #onContextBindingCalled(event) { + this.#emitter.emit("bindingcalled", event); + } + hasContext() { + return !!this.#context; + } + get context() { + return this.#context; + } + #executionContext() { + if (this.disposed) { + throw new Error(`Execution context is not available in detached frame or worker "${this.environment.url()}" (are you trying to evaluate?)`); + } + return this.#context; + } + /** + * Waits for the next context to be set on the isolated world. + */ + async #waitForExecutionContext() { + const error = new Error("Execution context was destroyed"); + const result = await firstValueFrom(fromEmitterEvent(this.#emitter, "context").pipe(raceWith(fromEmitterEvent(this.#emitter, "disposed").pipe(map(() => { + throw error; + })), timeout(this.timeoutSettings.timeout())))); + return result; + } + async evaluateHandle(pageFunction, ...args) { + pageFunction = withSourcePuppeteerURLIfNone(this.evaluateHandle.name, pageFunction); + let context = this.#executionContext(); + if (!context) { + context = await this.#waitForExecutionContext(); + } + return await context.evaluateHandle(pageFunction, ...args); + } + async evaluate(pageFunction, ...args) { + pageFunction = withSourcePuppeteerURLIfNone(this.evaluate.name, pageFunction); + let context = this.#executionContext(); + if (!context) { + context = await this.#waitForExecutionContext(); + } + return await context.evaluate(pageFunction, ...args); + } + async adoptBackendNode(backendNodeId) { + let context = this.#executionContext(); + if (!context) { + context = await this.#waitForExecutionContext(); + } + const { object } = await this.client.send("DOM.resolveNode", { + backendNodeId, + executionContextId: context.id + }); + return this.createCdpHandle(object); + } + async adoptHandle(handle) { + if (handle.realm === this) { + return await handle.evaluateHandle((value) => { + return value; + }); + } + const nodeInfo = await this.client.send("DOM.describeNode", { + objectId: handle.id + }); + return await this.adoptBackendNode(nodeInfo.node.backendNodeId); + } + async transferHandle(handle) { + if (handle.realm === this) { + return handle; + } + if (handle.remoteObject().objectId === void 0) { + return handle; + } + const info = await this.client.send("DOM.describeNode", { + objectId: handle.remoteObject().objectId + }); + const newHandle = await this.adoptBackendNode(info.node.backendNodeId); + await handle.dispose(); + return newHandle; + } + /** + * @internal + */ + createCdpHandle(remoteObject) { + if (remoteObject.subtype === "node") { + return new CdpElementHandle(this, remoteObject); + } + return new CdpJSHandle(this, remoteObject); + } + [disposeSymbol]() { + this.#context?.[disposeSymbol](); + this.#emitter.emit("disposed", void 0); + super[disposeSymbol](); + this.#emitter.removeAllListeners(); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/IsolatedWorlds.js +init_cjs_shim(); +var MAIN_WORLD = Symbol("mainWorld"); +var PUPPETEER_WORLD = Symbol("puppeteerWorld"); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/LifecycleWatcher.js +init_cjs_shim(); +var puppeteerToProtocolLifecycle = /* @__PURE__ */ new Map([ + ["load", "load"], + ["domcontentloaded", "DOMContentLoaded"], + ["networkidle0", "networkIdle"], + ["networkidle2", "networkAlmostIdle"] +]); +var LifecycleWatcher = class { + #expectedLifecycle; + #frame; + #timeout; + #navigationRequest = null; + #subscriptions = new DisposableStack(); + #initialLoaderId; + #terminationDeferred; + #sameDocumentNavigationDeferred = Deferred.create(); + #lifecycleDeferred = Deferred.create(); + #newDocumentNavigationDeferred = Deferred.create(); + #hasSameDocumentNavigation; + #swapped; + #navigationResponseReceived; + constructor(networkManager, frame, waitUntil, timeout2, signal) { + if (Array.isArray(waitUntil)) { + waitUntil = waitUntil.slice(); + } else if (typeof waitUntil === "string") { + waitUntil = [waitUntil]; + } + this.#initialLoaderId = frame._loaderId; + this.#expectedLifecycle = waitUntil.map((value) => { + const protocolEvent = puppeteerToProtocolLifecycle.get(value); + assert(protocolEvent, "Unknown value for options.waitUntil: " + value); + return protocolEvent; + }); + signal?.addEventListener("abort", () => { + this.#terminationDeferred.reject(signal.reason); + }); + this.#frame = frame; + this.#timeout = timeout2; + const frameManagerEmitter = this.#subscriptions.use(new EventEmitter(frame._frameManager)); + frameManagerEmitter.on(FrameManagerEvent.LifecycleEvent, this.#checkLifecycleComplete.bind(this)); + const frameEmitter = this.#subscriptions.use(new EventEmitter(frame)); + frameEmitter.on(FrameEvent.FrameNavigatedWithinDocument, this.#navigatedWithinDocument.bind(this)); + frameEmitter.on(FrameEvent.FrameNavigated, this.#navigated.bind(this)); + frameEmitter.on(FrameEvent.FrameSwapped, this.#frameSwapped.bind(this)); + frameEmitter.on(FrameEvent.FrameSwappedByActivation, this.#frameSwapped.bind(this)); + frameEmitter.on(FrameEvent.FrameDetached, this.#onFrameDetached.bind(this)); + const networkManagerEmitter = this.#subscriptions.use(new EventEmitter(networkManager)); + networkManagerEmitter.on(NetworkManagerEvent.Request, this.#onRequest.bind(this)); + networkManagerEmitter.on(NetworkManagerEvent.Response, this.#onResponse.bind(this)); + networkManagerEmitter.on(NetworkManagerEvent.RequestFailed, this.#onRequestFailed.bind(this)); + this.#terminationDeferred = Deferred.create({ + timeout: this.#timeout, + message: `Navigation timeout of ${this.#timeout} ms exceeded` + }); + this.#checkLifecycleComplete(); + } + #onRequest(request3) { + if (request3.frame() !== this.#frame || !request3.isNavigationRequest()) { + return; + } + this.#navigationRequest = request3; + this.#navigationResponseReceived?.resolve(); + this.#navigationResponseReceived = Deferred.create(); + if (request3.response() !== null) { + this.#navigationResponseReceived?.resolve(); + } + } + #onRequestFailed(request3) { + if (this.#navigationRequest?.id !== request3.id) { + return; + } + this.#navigationResponseReceived?.resolve(); + } + #onResponse(response) { + if (this.#navigationRequest?.id !== response.request().id) { + return; + } + this.#navigationResponseReceived?.resolve(); + } + #onFrameDetached(frame) { + if (this.#frame === frame) { + this.#terminationDeferred.resolve(new Error("Navigating frame was detached")); + return; + } + this.#checkLifecycleComplete(); + } + async navigationResponse() { + await this.#navigationResponseReceived?.valueOrThrow(); + return this.#navigationRequest ? this.#navigationRequest.response() : null; + } + sameDocumentNavigationPromise() { + return this.#sameDocumentNavigationDeferred.valueOrThrow(); + } + newDocumentNavigationPromise() { + return this.#newDocumentNavigationDeferred.valueOrThrow(); + } + lifecyclePromise() { + return this.#lifecycleDeferred.valueOrThrow(); + } + terminationPromise() { + return this.#terminationDeferred.valueOrThrow(); + } + #navigatedWithinDocument() { + this.#hasSameDocumentNavigation = true; + this.#checkLifecycleComplete(); + } + #navigated(navigationType) { + if (navigationType === "BackForwardCacheRestore") { + return this.#frameSwapped(); + } + this.#checkLifecycleComplete(); + } + #frameSwapped() { + this.#swapped = true; + this.#checkLifecycleComplete(); + } + #checkLifecycleComplete() { + if (!checkLifecycle(this.#frame, this.#expectedLifecycle)) { + return; + } + this.#lifecycleDeferred.resolve(); + if (this.#hasSameDocumentNavigation) { + this.#sameDocumentNavigationDeferred.resolve(void 0); + } + if (this.#swapped || this.#frame._loaderId !== this.#initialLoaderId) { + this.#newDocumentNavigationDeferred.resolve(void 0); + } + function checkLifecycle(frame, expectedLifecycle) { + for (const event of expectedLifecycle) { + if (!frame._lifecycleEvents.has(event)) { + return false; + } + } + for (const child of frame.childFrames()) { + if (child._hasStartedLoading && !checkLifecycle(child, expectedLifecycle)) { + return false; + } + } + return true; + } + } + dispose() { + this.#subscriptions.dispose(); + this.#terminationDeferred.resolve(new Error("LifecycleWatcher disposed")); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Frame.js +var __runInitializers2 = 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 __esDecorate2 = 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 CdpFrame = (() => { + let _classSuper = Frame; + let _instanceExtraInitializers = []; + let _goto_decorators; + let _waitForNavigation_decorators; + let _setContent_decorators; + let _addPreloadScript_decorators; + let _addExposedFunctionBinding_decorators; + let _removeExposedFunctionBinding_decorators; + let _waitForDevicePrompt_decorators; + return class CdpFrame extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + __esDecorate2(this, null, _goto_decorators, { kind: "method", name: "goto", static: false, private: false, access: { has: (obj) => "goto" in obj, get: (obj) => obj.goto }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _waitForNavigation_decorators, { kind: "method", name: "waitForNavigation", static: false, private: false, access: { has: (obj) => "waitForNavigation" in obj, get: (obj) => obj.waitForNavigation }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _setContent_decorators, { kind: "method", name: "setContent", static: false, private: false, access: { has: (obj) => "setContent" in obj, get: (obj) => obj.setContent }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _addPreloadScript_decorators, { kind: "method", name: "addPreloadScript", static: false, private: false, access: { has: (obj) => "addPreloadScript" in obj, get: (obj) => obj.addPreloadScript }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _addExposedFunctionBinding_decorators, { kind: "method", name: "addExposedFunctionBinding", static: false, private: false, access: { has: (obj) => "addExposedFunctionBinding" in obj, get: (obj) => obj.addExposedFunctionBinding }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _removeExposedFunctionBinding_decorators, { kind: "method", name: "removeExposedFunctionBinding", static: false, private: false, access: { has: (obj) => "removeExposedFunctionBinding" in obj, get: (obj) => obj.removeExposedFunctionBinding }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _waitForDevicePrompt_decorators, { kind: "method", name: "waitForDevicePrompt", static: false, private: false, access: { has: (obj) => "waitForDevicePrompt" in obj, get: (obj) => obj.waitForDevicePrompt }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + #url = (__runInitializers2(this, _instanceExtraInitializers), ""); + #detached = false; + #client; + _frameManager; + _loaderId = ""; + _lifecycleEvents = /* @__PURE__ */ new Set(); + _id; + _parentId; + accessibility; + worlds; + constructor(frameManager, frameId, parentFrameId, client) { + super(); + this._frameManager = frameManager; + this.#url = ""; + this._id = frameId; + this._parentId = parentFrameId; + this.#detached = false; + this.#client = client; + this._loaderId = ""; + this.worlds = { + [MAIN_WORLD]: new IsolatedWorld(this, this._frameManager.timeoutSettings), + [PUPPETEER_WORLD]: new IsolatedWorld(this, this._frameManager.timeoutSettings) + }; + this.accessibility = new Accessibility(this.worlds[MAIN_WORLD]); + this.on(FrameEvent.FrameSwappedByActivation, () => { + this._onLoadingStarted(); + this._onLoadingStopped(); + }); + this.worlds[MAIN_WORLD].emitter.on("consoleapicalled", this.#onMainWorldConsoleApiCalled.bind(this)); + this.worlds[MAIN_WORLD].emitter.on("bindingcalled", this.#onMainWorldBindingCalled.bind(this)); + } + #onMainWorldConsoleApiCalled(event) { + this._frameManager.emit(FrameManagerEvent.ConsoleApiCalled, [ + this.worlds[MAIN_WORLD], + event + ]); + } + #onMainWorldBindingCalled(event) { + this._frameManager.emit(FrameManagerEvent.BindingCalled, [ + this.worlds[MAIN_WORLD], + event + ]); + } + /** + * This is used internally in DevTools. + * + * @internal + */ + _client() { + return this.#client; + } + /** + * Updates the frame ID with the new ID. This happens when the main frame is + * replaced by a different frame. + */ + updateId(id) { + this._id = id; + } + updateClient(client) { + this.#client = client; + } + page() { + return this._frameManager.page(); + } + async goto(url, options = {}) { + const { referer = this._frameManager.networkManager.extraHTTPHeaders()["referer"], referrerPolicy = this._frameManager.networkManager.extraHTTPHeaders()["referer-policy"], waitUntil = ["load"], timeout: timeout2 = this._frameManager.timeoutSettings.navigationTimeout() } = options; + let ensureNewDocumentNavigation = false; + const watcher = new LifecycleWatcher(this._frameManager.networkManager, this, waitUntil, timeout2); + let error = await Deferred.race([ + navigate(this.#client, url, referer, referrerPolicy, this._id), + watcher.terminationPromise() + ]); + if (!error) { + error = await Deferred.race([ + watcher.terminationPromise(), + ensureNewDocumentNavigation ? watcher.newDocumentNavigationPromise() : watcher.sameDocumentNavigationPromise() + ]); + } + try { + if (error) { + throw error; + } + return await watcher.navigationResponse(); + } finally { + watcher.dispose(); + } + async function navigate(client, url2, referrer, referrerPolicy2, frameId) { + try { + const response = await client.send("Page.navigate", { + url: url2, + referrer, + frameId, + referrerPolicy: referrerPolicy2 + }); + ensureNewDocumentNavigation = !!response.loaderId; + if (response.errorText === "net::ERR_HTTP_RESPONSE_CODE_FAILURE") { + return null; + } + return response.errorText ? new Error(`${response.errorText} at ${url2}`) : null; + } catch (error2) { + if (isErrorLike(error2)) { + return error2; + } + throw error2; + } + } + } + async waitForNavigation(options = {}) { + const { waitUntil = ["load"], timeout: timeout2 = this._frameManager.timeoutSettings.navigationTimeout(), signal } = options; + const watcher = new LifecycleWatcher(this._frameManager.networkManager, this, waitUntil, timeout2, signal); + const error = await Deferred.race([ + watcher.terminationPromise(), + ...options.ignoreSameDocumentNavigation ? [] : [watcher.sameDocumentNavigationPromise()], + watcher.newDocumentNavigationPromise() + ]); + try { + if (error) { + throw error; + } + const result = await Deferred.race([watcher.terminationPromise(), watcher.navigationResponse()]); + if (result instanceof Error) { + throw error; + } + return result || null; + } finally { + watcher.dispose(); + } + } + get client() { + return this.#client; + } + mainRealm() { + return this.worlds[MAIN_WORLD]; + } + isolatedRealm() { + return this.worlds[PUPPETEER_WORLD]; + } + async setContent(html, options = {}) { + const { waitUntil = ["load"], timeout: timeout2 = this._frameManager.timeoutSettings.navigationTimeout() } = options; + await this.setFrameContent(html); + const watcher = new LifecycleWatcher(this._frameManager.networkManager, this, waitUntil, timeout2); + const error = await Deferred.race([ + watcher.terminationPromise(), + watcher.lifecyclePromise() + ]); + watcher.dispose(); + if (error) { + throw error; + } + } + url() { + return this.#url; + } + parentFrame() { + return this._frameManager._frameTree.parentFrame(this._id) || null; + } + childFrames() { + return this._frameManager._frameTree.childFrames(this._id); + } + #deviceRequestPromptManager() { + return this._frameManager._deviceRequestPromptManager(this.#client); + } + async addPreloadScript(preloadScript) { + const parentFrame = this.parentFrame(); + if (parentFrame && this.#client === parentFrame.client) { + return; + } + if (preloadScript.getIdForFrame(this)) { + return; + } + const { identifier } = await this.#client.send("Page.addScriptToEvaluateOnNewDocument", { + source: preloadScript.source + }); + preloadScript.setIdForFrame(this, identifier); + } + async addExposedFunctionBinding(binding) { + if (this !== this._frameManager.mainFrame() && !this._hasStartedLoading) { + return; + } + await Promise.all([ + this.#client.send("Runtime.addBinding", { + name: CDP_BINDING_PREFIX + binding.name + }), + this.evaluate(binding.initSource).catch(debugError) + ]); + } + async removeExposedFunctionBinding(binding) { + if (this !== this._frameManager.mainFrame() && !this._hasStartedLoading) { + return; + } + await Promise.all([ + this.#client.send("Runtime.removeBinding", { + name: CDP_BINDING_PREFIX + binding.name + }), + this.evaluate((name) => { + globalThis[name] = void 0; + }, binding.name).catch(debugError) + ]); + } + async waitForDevicePrompt(options = {}) { + return await this.#deviceRequestPromptManager().waitForDevicePrompt(options); + } + _navigated(framePayload) { + this._name = framePayload.name; + this.#url = `${framePayload.url}${framePayload.urlFragment || ""}`; + } + _navigatedWithinDocument(url) { + this.#url = url; + } + _onLifecycleEvent(loaderId, name) { + if (name === "init") { + this._loaderId = loaderId; + this._lifecycleEvents.clear(); + } + this._lifecycleEvents.add(name); + } + _onLoadingStopped() { + this._lifecycleEvents.add("DOMContentLoaded"); + this._lifecycleEvents.add("load"); + } + _onLoadingStarted() { + this._hasStartedLoading = true; + } + get detached() { + return this.#detached; + } + [(_goto_decorators = [throwIfDetached], _waitForNavigation_decorators = [throwIfDetached], _setContent_decorators = [throwIfDetached], _addPreloadScript_decorators = [throwIfDetached], _addExposedFunctionBinding_decorators = [throwIfDetached], _removeExposedFunctionBinding_decorators = [throwIfDetached], _waitForDevicePrompt_decorators = [throwIfDetached], disposeSymbol)]() { + if (this.#detached) { + return; + } + this.#detached = true; + this.worlds[MAIN_WORLD][disposeSymbol](); + this.worlds[PUPPETEER_WORLD][disposeSymbol](); + } + exposeFunction() { + throw new UnsupportedOperation(); + } + async frameElement() { + const isFirefox = this.page().target()._targetManager() instanceof FirefoxTargetManager; + if (isFirefox) { + return await super.frameElement(); + } + const parent = this.parentFrame(); + if (!parent) { + return null; + } + const { backendNodeId } = await parent.client.send("DOM.getFrameOwner", { + frameId: this._id + }); + return await parent.mainRealm().adoptBackendNode(backendNodeId); + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/FrameTree.js +init_cjs_shim(); +var FrameTree = class { + #frames = /* @__PURE__ */ new Map(); + // frameID -> parentFrameID + #parentIds = /* @__PURE__ */ new Map(); + // frameID -> childFrameIDs + #childIds = /* @__PURE__ */ new Map(); + #mainFrame; + #isMainFrameStale = false; + #waitRequests = /* @__PURE__ */ new Map(); + getMainFrame() { + return this.#mainFrame; + } + getById(frameId) { + return this.#frames.get(frameId); + } + /** + * Returns a promise that is resolved once the frame with + * the given ID is added to the tree. + */ + waitForFrame(frameId) { + const frame = this.getById(frameId); + if (frame) { + return Promise.resolve(frame); + } + const deferred = Deferred.create(); + const callbacks = this.#waitRequests.get(frameId) || /* @__PURE__ */ new Set(); + callbacks.add(deferred); + return deferred.valueOrThrow(); + } + frames() { + return Array.from(this.#frames.values()); + } + addFrame(frame) { + this.#frames.set(frame._id, frame); + if (frame._parentId) { + this.#parentIds.set(frame._id, frame._parentId); + if (!this.#childIds.has(frame._parentId)) { + this.#childIds.set(frame._parentId, /* @__PURE__ */ new Set()); + } + this.#childIds.get(frame._parentId).add(frame._id); + } else if (!this.#mainFrame || this.#isMainFrameStale) { + this.#mainFrame = frame; + this.#isMainFrameStale = false; + } + this.#waitRequests.get(frame._id)?.forEach((request3) => { + return request3.resolve(frame); + }); + } + removeFrame(frame) { + this.#frames.delete(frame._id); + this.#parentIds.delete(frame._id); + if (frame._parentId) { + this.#childIds.get(frame._parentId)?.delete(frame._id); + } else { + this.#isMainFrameStale = true; + } + } + childFrames(frameId) { + const childIds = this.#childIds.get(frameId); + if (!childIds) { + return []; + } + return Array.from(childIds).map((id) => { + return this.getById(id); + }).filter((frame) => { + return frame !== void 0; + }); + } + parentFrame(frameId) { + const parentId = this.#parentIds.get(frameId); + return parentId ? this.getById(parentId) : void 0; + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/NetworkManager.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/HTTPRequest.js +init_cjs_shim(); +var CdpHTTPRequest = class extends HTTPRequest { + id; + #client; + #isNavigationRequest; + #url; + #resourceType; + #method; + #hasPostData = false; + #postData; + #headers = {}; + #frame; + #initiator; + get client() { + return this.#client; + } + set client(newClient) { + this.#client = newClient; + } + constructor(client, frame, interceptionId, allowInterception, data, redirectChain) { + super(); + this.#client = client; + this.id = data.requestId; + this.#isNavigationRequest = data.requestId === data.loaderId && data.type === "Document"; + this._interceptionId = interceptionId; + this.#url = data.request.url; + this.#resourceType = (data.type || "other").toLowerCase(); + this.#method = data.request.method; + this.#postData = data.request.postData; + this.#hasPostData = data.request.hasPostData ?? false; + this.#frame = frame; + this._redirectChain = redirectChain; + this.#initiator = data.initiator; + this.interception.enabled = allowInterception; + for (const [key, value] of Object.entries(data.request.headers)) { + this.#headers[key.toLowerCase()] = value; + } + } + url() { + return this.#url; + } + resourceType() { + return this.#resourceType; + } + method() { + return this.#method; + } + postData() { + return this.#postData; + } + hasPostData() { + return this.#hasPostData; + } + async fetchPostData() { + try { + const result = await this.#client.send("Network.getRequestPostData", { + requestId: this.id + }); + return result.postData; + } catch (err) { + debugError(err); + return; + } + } + headers() { + return this.#headers; + } + response() { + return this._response; + } + frame() { + return this.#frame; + } + isNavigationRequest() { + return this.#isNavigationRequest; + } + initiator() { + return this.#initiator; + } + redirectChain() { + return this._redirectChain.slice(); + } + failure() { + if (!this._failureText) { + return null; + } + return { + errorText: this._failureText + }; + } + /** + * @internal + */ + async _continue(overrides = {}) { + const { url, method, postData, headers } = overrides; + this.interception.handled = true; + const postDataBinaryBase64 = postData ? stringToBase64(postData) : void 0; + if (this._interceptionId === void 0) { + throw new Error("HTTPRequest is missing _interceptionId needed for Fetch.continueRequest"); + } + await this.#client.send("Fetch.continueRequest", { + requestId: this._interceptionId, + url, + method, + postData: postDataBinaryBase64, + headers: headers ? headersArray(headers) : void 0 + }).catch((error) => { + this.interception.handled = false; + return handleError(error); + }); + } + async _respond(response) { + this.interception.handled = true; + let parsedBody; + if (response.body) { + parsedBody = HTTPRequest.getResponse(response.body); + } + const responseHeaders = {}; + if (response.headers) { + for (const header of Object.keys(response.headers)) { + const value = response.headers[header]; + responseHeaders[header.toLowerCase()] = Array.isArray(value) ? value.map((item) => { + return String(item); + }) : String(value); + } + } + if (response.contentType) { + responseHeaders["content-type"] = response.contentType; + } + if (parsedBody?.contentLength && !("content-length" in responseHeaders)) { + responseHeaders["content-length"] = String(parsedBody.contentLength); + } + const status = response.status || 200; + if (this._interceptionId === void 0) { + throw new Error("HTTPRequest is missing _interceptionId needed for Fetch.fulfillRequest"); + } + await this.#client.send("Fetch.fulfillRequest", { + requestId: this._interceptionId, + responseCode: status, + responsePhrase: STATUS_TEXTS[status], + responseHeaders: headersArray(responseHeaders), + body: parsedBody?.base64 + }).catch((error) => { + this.interception.handled = false; + return handleError(error); + }); + } + async _abort(errorReason) { + this.interception.handled = true; + if (this._interceptionId === void 0) { + throw new Error("HTTPRequest is missing _interceptionId needed for Fetch.failRequest"); + } + await this.#client.send("Fetch.failRequest", { + requestId: this._interceptionId, + errorReason: errorReason || "Failed" + }).catch(handleError); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/HTTPResponse.js +init_cjs_shim(); +var CdpHTTPResponse = class extends HTTPResponse { + #request; + #contentPromise = null; + #bodyLoadedDeferred = Deferred.create(); + #remoteAddress; + #status; + #statusText; + #url; + #fromDiskCache; + #fromServiceWorker; + #headers = {}; + #securityDetails; + #timing; + constructor(request3, responsePayload, extraInfo) { + super(); + this.#request = request3; + this.#remoteAddress = { + ip: responsePayload.remoteIPAddress, + port: responsePayload.remotePort + }; + this.#statusText = this.#parseStatusTextFromExtraInfo(extraInfo) || responsePayload.statusText; + this.#url = request3.url(); + this.#fromDiskCache = !!responsePayload.fromDiskCache; + this.#fromServiceWorker = !!responsePayload.fromServiceWorker; + this.#status = extraInfo ? extraInfo.statusCode : responsePayload.status; + const headers = extraInfo ? extraInfo.headers : responsePayload.headers; + for (const [key, value] of Object.entries(headers)) { + this.#headers[key.toLowerCase()] = value; + } + this.#securityDetails = responsePayload.securityDetails ? new SecurityDetails(responsePayload.securityDetails) : null; + this.#timing = responsePayload.timing || null; + } + #parseStatusTextFromExtraInfo(extraInfo) { + if (!extraInfo || !extraInfo.headersText) { + return; + } + const firstLine = extraInfo.headersText.split("\r", 1)[0]; + if (!firstLine || firstLine.length > 1e3) { + return; + } + const match = firstLine.match(/[^ ]* [^ ]* (.*)/); + if (!match) { + return; + } + const statusText = match[1]; + if (!statusText) { + return; + } + return statusText; + } + _resolveBody(err) { + if (err) { + return this.#bodyLoadedDeferred.reject(err); + } + return this.#bodyLoadedDeferred.resolve(); + } + remoteAddress() { + return this.#remoteAddress; + } + url() { + return this.#url; + } + status() { + return this.#status; + } + statusText() { + return this.#statusText; + } + headers() { + return this.#headers; + } + securityDetails() { + return this.#securityDetails; + } + timing() { + return this.#timing; + } + content() { + if (!this.#contentPromise) { + this.#contentPromise = this.#bodyLoadedDeferred.valueOrThrow().then(async () => { + try { + const response = await this.#request.client.send("Network.getResponseBody", { + requestId: this.#request.id + }); + return stringToTypedArray(response.body, response.base64Encoded); + } catch (error) { + if (error instanceof ProtocolError && error.originalMessage === "No resource with given identifier found") { + throw new ProtocolError("Could not load body for this request. This might happen if the request is a preflight request."); + } + throw error; + } + }); + } + return this.#contentPromise; + } + request() { + return this.#request; + } + fromCache() { + return this.#fromDiskCache || this.#request._fromMemoryCache; + } + fromServiceWorker() { + return this.#fromServiceWorker; + } + frame() { + return this.#request.frame(); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/NetworkEventManager.js +init_cjs_shim(); +var NetworkEventManager = class { + /** + * There are four possible orders of events: + * A. `_onRequestWillBeSent` + * B. `_onRequestWillBeSent`, `_onRequestPaused` + * C. `_onRequestPaused`, `_onRequestWillBeSent` + * D. `_onRequestPaused`, `_onRequestWillBeSent`, `_onRequestPaused`, + * `_onRequestWillBeSent`, `_onRequestPaused`, `_onRequestPaused` + * (see crbug.com/1196004) + * + * For `_onRequest` we need the event from `_onRequestWillBeSent` and + * optionally the `interceptionId` from `_onRequestPaused`. + * + * If request interception is disabled, call `_onRequest` once per call to + * `_onRequestWillBeSent`. + * If request interception is enabled, call `_onRequest` once per call to + * `_onRequestPaused` (once per `interceptionId`). + * + * Events are stored to allow for subsequent events to call `_onRequest`. + * + * Note that (chains of) redirect requests have the same `requestId` (!) as + * the original request. We have to anticipate series of events like these: + * A. `_onRequestWillBeSent`, + * `_onRequestWillBeSent`, ... + * B. `_onRequestWillBeSent`, `_onRequestPaused`, + * `_onRequestWillBeSent`, `_onRequestPaused`, ... + * C. `_onRequestWillBeSent`, `_onRequestPaused`, + * `_onRequestPaused`, `_onRequestWillBeSent`, ... + * D. `_onRequestPaused`, `_onRequestWillBeSent`, + * `_onRequestPaused`, `_onRequestWillBeSent`, `_onRequestPaused`, + * `_onRequestWillBeSent`, `_onRequestPaused`, `_onRequestPaused`, ... + * (see crbug.com/1196004) + */ + #requestWillBeSentMap = /* @__PURE__ */ new Map(); + #requestPausedMap = /* @__PURE__ */ new Map(); + #httpRequestsMap = /* @__PURE__ */ new Map(); + /* + * The below maps are used to reconcile Network.responseReceivedExtraInfo + * events with their corresponding request. Each response and redirect + * response gets an ExtraInfo event, and we don't know which will come first. + * This means that we have to store a Response or an ExtraInfo for each + * response, and emit the event when we get both of them. In addition, to + * handle redirects, we have to make them Arrays to represent the chain of + * events. + */ + #responseReceivedExtraInfoMap = /* @__PURE__ */ new Map(); + #queuedRedirectInfoMap = /* @__PURE__ */ new Map(); + #queuedEventGroupMap = /* @__PURE__ */ new Map(); + forget(networkRequestId) { + this.#requestWillBeSentMap.delete(networkRequestId); + this.#requestPausedMap.delete(networkRequestId); + this.#queuedEventGroupMap.delete(networkRequestId); + this.#queuedRedirectInfoMap.delete(networkRequestId); + this.#responseReceivedExtraInfoMap.delete(networkRequestId); + } + responseExtraInfo(networkRequestId) { + if (!this.#responseReceivedExtraInfoMap.has(networkRequestId)) { + this.#responseReceivedExtraInfoMap.set(networkRequestId, []); + } + return this.#responseReceivedExtraInfoMap.get(networkRequestId); + } + queuedRedirectInfo(fetchRequestId) { + if (!this.#queuedRedirectInfoMap.has(fetchRequestId)) { + this.#queuedRedirectInfoMap.set(fetchRequestId, []); + } + return this.#queuedRedirectInfoMap.get(fetchRequestId); + } + queueRedirectInfo(fetchRequestId, redirectInfo) { + this.queuedRedirectInfo(fetchRequestId).push(redirectInfo); + } + takeQueuedRedirectInfo(fetchRequestId) { + return this.queuedRedirectInfo(fetchRequestId).shift(); + } + inFlightRequestsCount() { + let inFlightRequestCounter = 0; + for (const request3 of this.#httpRequestsMap.values()) { + if (!request3.response()) { + inFlightRequestCounter++; + } + } + return inFlightRequestCounter; + } + storeRequestWillBeSent(networkRequestId, event) { + this.#requestWillBeSentMap.set(networkRequestId, event); + } + getRequestWillBeSent(networkRequestId) { + return this.#requestWillBeSentMap.get(networkRequestId); + } + forgetRequestWillBeSent(networkRequestId) { + this.#requestWillBeSentMap.delete(networkRequestId); + } + getRequestPaused(networkRequestId) { + return this.#requestPausedMap.get(networkRequestId); + } + forgetRequestPaused(networkRequestId) { + this.#requestPausedMap.delete(networkRequestId); + } + storeRequestPaused(networkRequestId, event) { + this.#requestPausedMap.set(networkRequestId, event); + } + getRequest(networkRequestId) { + return this.#httpRequestsMap.get(networkRequestId); + } + storeRequest(networkRequestId, request3) { + this.#httpRequestsMap.set(networkRequestId, request3); + } + forgetRequest(networkRequestId) { + this.#httpRequestsMap.delete(networkRequestId); + } + getQueuedEventGroup(networkRequestId) { + return this.#queuedEventGroupMap.get(networkRequestId); + } + queueEventGroup(networkRequestId, event) { + this.#queuedEventGroupMap.set(networkRequestId, event); + } + forgetQueuedEventGroup(networkRequestId) { + this.#queuedEventGroupMap.delete(networkRequestId); + } + printState() { + function replacer(_key, value) { + if (value instanceof Map) { + return { + dataType: "Map", + value: Array.from(value.entries()) + // or with spread: value: [...value] + }; + } else if (value instanceof CdpHTTPRequest) { + return { + dataType: "CdpHTTPRequest", + value: `${value.id}: ${value.url()}` + }; + } + { + return value; + } + } + console.log("httpRequestsMap", JSON.stringify(this.#httpRequestsMap, replacer, 2)); + console.log("requestWillBeSentMap", JSON.stringify(this.#requestWillBeSentMap, replacer, 2)); + console.log("requestWillBeSentMap", JSON.stringify(this.#responseReceivedExtraInfoMap, replacer, 2)); + console.log("requestWillBeSentMap", JSON.stringify(this.#requestPausedMap, replacer, 2)); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/NetworkManager.js +var NetworkManager = class extends EventEmitter { + #frameManager; + #networkEventManager = new NetworkEventManager(); + #extraHTTPHeaders; + #credentials = null; + #attemptedAuthentications = /* @__PURE__ */ new Set(); + #userRequestInterceptionEnabled = false; + #protocolRequestInterceptionEnabled = false; + #userCacheDisabled; + #emulatedNetworkConditions; + #userAgent; + #userAgentMetadata; + #handlers = [ + ["Fetch.requestPaused", this.#onRequestPaused], + ["Fetch.authRequired", this.#onAuthRequired], + ["Network.requestWillBeSent", this.#onRequestWillBeSent], + ["Network.requestServedFromCache", this.#onRequestServedFromCache], + ["Network.responseReceived", this.#onResponseReceived], + ["Network.loadingFinished", this.#onLoadingFinished], + ["Network.loadingFailed", this.#onLoadingFailed], + ["Network.responseReceivedExtraInfo", this.#onResponseReceivedExtraInfo], + [CDPSessionEvent.Disconnected, this.#removeClient] + ]; + #clients = /* @__PURE__ */ new Map(); + constructor(frameManager) { + super(); + this.#frameManager = frameManager; + } + async addClient(client) { + if (this.#clients.has(client)) { + return; + } + const subscriptions = new DisposableStack(); + this.#clients.set(client, subscriptions); + const clientEmitter = subscriptions.use(new EventEmitter(client)); + for (const [event, handler] of this.#handlers) { + clientEmitter.on(event, (arg) => { + return handler.bind(this)(client, arg); + }); + } + await Promise.all([ + client.send("Network.enable"), + this.#applyExtraHTTPHeaders(client), + this.#applyNetworkConditions(client), + this.#applyProtocolCacheDisabled(client), + this.#applyProtocolRequestInterception(client), + this.#applyUserAgent(client) + ]); + } + async #removeClient(client) { + this.#clients.get(client)?.dispose(); + this.#clients.delete(client); + } + async authenticate(credentials) { + this.#credentials = credentials; + const enabled = this.#userRequestInterceptionEnabled || !!this.#credentials; + if (enabled === this.#protocolRequestInterceptionEnabled) { + return; + } + this.#protocolRequestInterceptionEnabled = enabled; + await this.#applyToAllClients(this.#applyProtocolRequestInterception.bind(this)); + } + async setExtraHTTPHeaders(headers) { + const extraHTTPHeaders = {}; + for (const [key, value] of Object.entries(headers)) { + assert(isString(value), `Expected value of header "${key}" to be String, but "${typeof value}" is found.`); + extraHTTPHeaders[key.toLowerCase()] = value; + } + this.#extraHTTPHeaders = extraHTTPHeaders; + await this.#applyToAllClients(this.#applyExtraHTTPHeaders.bind(this)); + } + async #applyExtraHTTPHeaders(client) { + if (this.#extraHTTPHeaders === void 0) { + return; + } + await client.send("Network.setExtraHTTPHeaders", { + headers: this.#extraHTTPHeaders + }); + } + extraHTTPHeaders() { + return Object.assign({}, this.#extraHTTPHeaders); + } + inFlightRequestsCount() { + return this.#networkEventManager.inFlightRequestsCount(); + } + async setOfflineMode(value) { + if (!this.#emulatedNetworkConditions) { + this.#emulatedNetworkConditions = { + offline: false, + upload: -1, + download: -1, + latency: 0 + }; + } + this.#emulatedNetworkConditions.offline = value; + await this.#applyToAllClients(this.#applyNetworkConditions.bind(this)); + } + async emulateNetworkConditions(networkConditions) { + if (!this.#emulatedNetworkConditions) { + this.#emulatedNetworkConditions = { + offline: false, + upload: -1, + download: -1, + latency: 0 + }; + } + this.#emulatedNetworkConditions.upload = networkConditions ? networkConditions.upload : -1; + this.#emulatedNetworkConditions.download = networkConditions ? networkConditions.download : -1; + this.#emulatedNetworkConditions.latency = networkConditions ? networkConditions.latency : 0; + await this.#applyToAllClients(this.#applyNetworkConditions.bind(this)); + } + async #applyToAllClients(fn) { + await Promise.all(Array.from(this.#clients.keys()).map((client) => { + return fn(client); + })); + } + async #applyNetworkConditions(client) { + if (this.#emulatedNetworkConditions === void 0) { + return; + } + await client.send("Network.emulateNetworkConditions", { + offline: this.#emulatedNetworkConditions.offline, + latency: this.#emulatedNetworkConditions.latency, + uploadThroughput: this.#emulatedNetworkConditions.upload, + downloadThroughput: this.#emulatedNetworkConditions.download + }); + } + async setUserAgent(userAgent, userAgentMetadata) { + this.#userAgent = userAgent; + this.#userAgentMetadata = userAgentMetadata; + await this.#applyToAllClients(this.#applyUserAgent.bind(this)); + } + async #applyUserAgent(client) { + if (this.#userAgent === void 0) { + return; + } + await client.send("Network.setUserAgentOverride", { + userAgent: this.#userAgent, + userAgentMetadata: this.#userAgentMetadata + }); + } + async setCacheEnabled(enabled) { + this.#userCacheDisabled = !enabled; + await this.#applyToAllClients(this.#applyProtocolCacheDisabled.bind(this)); + } + async setRequestInterception(value) { + this.#userRequestInterceptionEnabled = value; + const enabled = this.#userRequestInterceptionEnabled || !!this.#credentials; + if (enabled === this.#protocolRequestInterceptionEnabled) { + return; + } + this.#protocolRequestInterceptionEnabled = enabled; + await this.#applyToAllClients(this.#applyProtocolRequestInterception.bind(this)); + } + async #applyProtocolRequestInterception(client) { + if (this.#userCacheDisabled === void 0) { + this.#userCacheDisabled = false; + } + if (this.#protocolRequestInterceptionEnabled) { + await Promise.all([ + this.#applyProtocolCacheDisabled(client), + client.send("Fetch.enable", { + handleAuthRequests: true, + patterns: [{ urlPattern: "*" }] + }) + ]); + } else { + await Promise.all([ + this.#applyProtocolCacheDisabled(client), + client.send("Fetch.disable") + ]); + } + } + async #applyProtocolCacheDisabled(client) { + if (this.#userCacheDisabled === void 0) { + return; + } + await client.send("Network.setCacheDisabled", { + cacheDisabled: this.#userCacheDisabled + }); + } + #onRequestWillBeSent(client, event) { + if (this.#userRequestInterceptionEnabled && !event.request.url.startsWith("data:")) { + const { requestId: networkRequestId } = event; + this.#networkEventManager.storeRequestWillBeSent(networkRequestId, event); + const requestPausedEvent = this.#networkEventManager.getRequestPaused(networkRequestId); + if (requestPausedEvent) { + const { requestId: fetchRequestId } = requestPausedEvent; + this.#patchRequestEventHeaders(event, requestPausedEvent); + this.#onRequest(client, event, fetchRequestId); + this.#networkEventManager.forgetRequestPaused(networkRequestId); + } + return; + } + this.#onRequest(client, event, void 0); + } + #onAuthRequired(client, event) { + let response = "Default"; + if (this.#attemptedAuthentications.has(event.requestId)) { + response = "CancelAuth"; + } else if (this.#credentials) { + response = "ProvideCredentials"; + this.#attemptedAuthentications.add(event.requestId); + } + const { username, password } = this.#credentials || { + username: void 0, + password: void 0 + }; + client.send("Fetch.continueWithAuth", { + requestId: event.requestId, + authChallengeResponse: { response, username, password } + }).catch(debugError); + } + /** + * CDP may send a Fetch.requestPaused without or before a + * Network.requestWillBeSent + * + * CDP may send multiple Fetch.requestPaused + * for the same Network.requestWillBeSent. + */ + #onRequestPaused(client, event) { + if (!this.#userRequestInterceptionEnabled && this.#protocolRequestInterceptionEnabled) { + client.send("Fetch.continueRequest", { + requestId: event.requestId + }).catch(debugError); + } + const { networkId: networkRequestId, requestId: fetchRequestId } = event; + if (!networkRequestId) { + this.#onRequestWithoutNetworkInstrumentation(client, event); + return; + } + const requestWillBeSentEvent = (() => { + const requestWillBeSentEvent2 = this.#networkEventManager.getRequestWillBeSent(networkRequestId); + if (requestWillBeSentEvent2 && (requestWillBeSentEvent2.request.url !== event.request.url || requestWillBeSentEvent2.request.method !== event.request.method)) { + this.#networkEventManager.forgetRequestWillBeSent(networkRequestId); + return; + } + return requestWillBeSentEvent2; + })(); + if (requestWillBeSentEvent) { + this.#patchRequestEventHeaders(requestWillBeSentEvent, event); + this.#onRequest(client, requestWillBeSentEvent, fetchRequestId); + } else { + this.#networkEventManager.storeRequestPaused(networkRequestId, event); + } + } + #patchRequestEventHeaders(requestWillBeSentEvent, requestPausedEvent) { + requestWillBeSentEvent.request.headers = { + ...requestWillBeSentEvent.request.headers, + // includes extra headers, like: Accept, Origin + ...requestPausedEvent.request.headers + }; + } + #onRequestWithoutNetworkInstrumentation(client, event) { + const frame = event.frameId ? this.#frameManager.frame(event.frameId) : null; + const request3 = new CdpHTTPRequest(client, frame, event.requestId, this.#userRequestInterceptionEnabled, event, []); + this.emit(NetworkManagerEvent.Request, request3); + void request3.finalizeInterceptions(); + } + #onRequest(client, event, fetchRequestId, fromMemoryCache = false) { + let redirectChain = []; + if (event.redirectResponse) { + let redirectResponseExtraInfo = null; + if (event.redirectHasExtraInfo) { + redirectResponseExtraInfo = this.#networkEventManager.responseExtraInfo(event.requestId).shift(); + if (!redirectResponseExtraInfo) { + this.#networkEventManager.queueRedirectInfo(event.requestId, { + event, + fetchRequestId + }); + return; + } + } + const request4 = this.#networkEventManager.getRequest(event.requestId); + if (request4) { + this.#handleRequestRedirect(client, request4, event.redirectResponse, redirectResponseExtraInfo); + redirectChain = request4._redirectChain; + } + } + const frame = event.frameId ? this.#frameManager.frame(event.frameId) : null; + const request3 = new CdpHTTPRequest(client, frame, fetchRequestId, this.#userRequestInterceptionEnabled, event, redirectChain); + request3._fromMemoryCache = fromMemoryCache; + this.#networkEventManager.storeRequest(event.requestId, request3); + this.emit(NetworkManagerEvent.Request, request3); + void request3.finalizeInterceptions(); + } + #onRequestServedFromCache(client, event) { + const requestWillBeSentEvent = this.#networkEventManager.getRequestWillBeSent(event.requestId); + let request3 = this.#networkEventManager.getRequest(event.requestId); + if (request3) { + request3._fromMemoryCache = true; + } + if (!request3 && requestWillBeSentEvent) { + this.#onRequest(client, requestWillBeSentEvent, void 0, true); + request3 = this.#networkEventManager.getRequest(event.requestId); + } + if (!request3) { + debugError(new Error(`Request ${event.requestId} was served from cache but we could not find the corresponding request object`)); + return; + } + this.emit(NetworkManagerEvent.RequestServedFromCache, request3); + } + #handleRequestRedirect(_client, request3, responsePayload, extraInfo) { + const response = new CdpHTTPResponse(request3, responsePayload, extraInfo); + request3._response = response; + request3._redirectChain.push(request3); + response._resolveBody(new Error("Response body is unavailable for redirect responses")); + this.#forgetRequest(request3, false); + this.emit(NetworkManagerEvent.Response, response); + this.emit(NetworkManagerEvent.RequestFinished, request3); + } + #emitResponseEvent(_client, responseReceived, extraInfo) { + const request3 = this.#networkEventManager.getRequest(responseReceived.requestId); + if (!request3) { + return; + } + const extraInfos = this.#networkEventManager.responseExtraInfo(responseReceived.requestId); + if (extraInfos.length) { + debugError(new Error("Unexpected extraInfo events for request " + responseReceived.requestId)); + } + if (responseReceived.response.fromDiskCache) { + extraInfo = null; + } + const response = new CdpHTTPResponse(request3, responseReceived.response, extraInfo); + request3._response = response; + this.emit(NetworkManagerEvent.Response, response); + } + #onResponseReceived(client, event) { + const request3 = this.#networkEventManager.getRequest(event.requestId); + let extraInfo = null; + if (request3 && !request3._fromMemoryCache && event.hasExtraInfo) { + extraInfo = this.#networkEventManager.responseExtraInfo(event.requestId).shift(); + if (!extraInfo) { + this.#networkEventManager.queueEventGroup(event.requestId, { + responseReceivedEvent: event + }); + return; + } + } + this.#emitResponseEvent(client, event, extraInfo); + } + #onResponseReceivedExtraInfo(client, event) { + const redirectInfo = this.#networkEventManager.takeQueuedRedirectInfo(event.requestId); + if (redirectInfo) { + this.#networkEventManager.responseExtraInfo(event.requestId).push(event); + this.#onRequest(client, redirectInfo.event, redirectInfo.fetchRequestId); + return; + } + const queuedEvents = this.#networkEventManager.getQueuedEventGroup(event.requestId); + if (queuedEvents) { + this.#networkEventManager.forgetQueuedEventGroup(event.requestId); + this.#emitResponseEvent(client, queuedEvents.responseReceivedEvent, event); + if (queuedEvents.loadingFinishedEvent) { + this.#emitLoadingFinished(client, queuedEvents.loadingFinishedEvent); + } + if (queuedEvents.loadingFailedEvent) { + this.#emitLoadingFailed(client, queuedEvents.loadingFailedEvent); + } + return; + } + this.#networkEventManager.responseExtraInfo(event.requestId).push(event); + } + #forgetRequest(request3, events) { + const requestId = request3.id; + const interceptionId = request3._interceptionId; + this.#networkEventManager.forgetRequest(requestId); + if (interceptionId !== void 0) { + this.#attemptedAuthentications.delete(interceptionId); + } + if (events) { + this.#networkEventManager.forget(requestId); + } + } + #onLoadingFinished(client, event) { + const queuedEvents = this.#networkEventManager.getQueuedEventGroup(event.requestId); + if (queuedEvents) { + queuedEvents.loadingFinishedEvent = event; + } else { + this.#emitLoadingFinished(client, event); + } + } + #emitLoadingFinished(client, event) { + const request3 = this.#networkEventManager.getRequest(event.requestId); + if (!request3) { + return; + } + this.#maybeReassignOOPIFRequestClient(client, request3); + if (request3.response()) { + request3.response()?._resolveBody(); + } + this.#forgetRequest(request3, true); + this.emit(NetworkManagerEvent.RequestFinished, request3); + } + #onLoadingFailed(client, event) { + const queuedEvents = this.#networkEventManager.getQueuedEventGroup(event.requestId); + if (queuedEvents) { + queuedEvents.loadingFailedEvent = event; + } else { + this.#emitLoadingFailed(client, event); + } + } + #emitLoadingFailed(client, event) { + const request3 = this.#networkEventManager.getRequest(event.requestId); + if (!request3) { + return; + } + this.#maybeReassignOOPIFRequestClient(client, request3); + request3._failureText = event.errorText; + const response = request3.response(); + if (response) { + response._resolveBody(); + } + this.#forgetRequest(request3, true); + this.emit(NetworkManagerEvent.RequestFailed, request3); + } + #maybeReassignOOPIFRequestClient(client, request3) { + if (client !== request3.client && request3.isNavigationRequest()) { + request3.client = client; + } + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/FrameManager.js +var TIME_FOR_WAITING_FOR_SWAP = 100; +var FrameManager = class extends EventEmitter { + #page; + #networkManager; + #timeoutSettings; + #isolatedWorlds = /* @__PURE__ */ new Set(); + #client; + #scriptsToEvaluateOnNewDocument = /* @__PURE__ */ new Map(); + #bindings = /* @__PURE__ */ new Set(); + _frameTree = new FrameTree(); + /** + * Set of frame IDs stored to indicate if a frame has received a + * frameNavigated event so that frame tree responses could be ignored as the + * frameNavigated event usually contains the latest information. + */ + #frameNavigatedReceived = /* @__PURE__ */ new Set(); + #deviceRequestPromptManagerMap = /* @__PURE__ */ new WeakMap(); + #frameTreeHandled; + get timeoutSettings() { + return this.#timeoutSettings; + } + get networkManager() { + return this.#networkManager; + } + get client() { + return this.#client; + } + constructor(client, page, timeoutSettings) { + super(); + this.#client = client; + this.#page = page; + this.#networkManager = new NetworkManager(this); + this.#timeoutSettings = timeoutSettings; + this.setupEventListeners(this.#client); + client.once(CDPSessionEvent.Disconnected, () => { + this.#onClientDisconnect().catch(debugError); + }); + } + /** + * Called when the frame's client is disconnected. We don't know if the + * disconnect means that the frame is removed or if it will be replaced by a + * new frame. Therefore, we wait for a swap event. + */ + async #onClientDisconnect() { + const mainFrame = this._frameTree.getMainFrame(); + if (!mainFrame) { + return; + } + for (const child of mainFrame.childFrames()) { + this.#removeFramesRecursively(child); + } + const swapped = Deferred.create({ + timeout: TIME_FOR_WAITING_FOR_SWAP, + message: "Frame was not swapped" + }); + mainFrame.once(FrameEvent.FrameSwappedByActivation, () => { + swapped.resolve(); + }); + try { + await swapped.valueOrThrow(); + } catch { + this.#removeFramesRecursively(mainFrame); + } + } + /** + * When the main frame is replaced by another main frame, + * we maintain the main frame object identity while updating + * its frame tree and ID. + */ + async swapFrameTree(client) { + this.#client = client; + assert(this.#client instanceof CdpCDPSession, "CDPSession is not an instance of CDPSessionImpl."); + const frame = this._frameTree.getMainFrame(); + if (frame) { + this.#frameNavigatedReceived.add(this.#client._target()._targetId); + this._frameTree.removeFrame(frame); + frame.updateId(this.#client._target()._targetId); + this._frameTree.addFrame(frame); + frame.updateClient(client); + } + this.setupEventListeners(client); + client.once(CDPSessionEvent.Disconnected, () => { + this.#onClientDisconnect().catch(debugError); + }); + await this.initialize(client, frame); + await this.#networkManager.addClient(client); + if (frame) { + frame.emit(FrameEvent.FrameSwappedByActivation, void 0); + } + } + async registerSpeculativeSession(client) { + await this.#networkManager.addClient(client); + } + setupEventListeners(session) { + session.on("Page.frameAttached", async (event) => { + await this.#frameTreeHandled?.valueOrThrow(); + this.#onFrameAttached(session, event.frameId, event.parentFrameId); + }); + session.on("Page.frameNavigated", async (event) => { + this.#frameNavigatedReceived.add(event.frame.id); + await this.#frameTreeHandled?.valueOrThrow(); + void this.#onFrameNavigated(event.frame, event.type); + }); + session.on("Page.navigatedWithinDocument", async (event) => { + await this.#frameTreeHandled?.valueOrThrow(); + this.#onFrameNavigatedWithinDocument(event.frameId, event.url); + }); + session.on("Page.frameDetached", async (event) => { + await this.#frameTreeHandled?.valueOrThrow(); + this.#onFrameDetached(event.frameId, event.reason); + }); + session.on("Page.frameStartedLoading", async (event) => { + await this.#frameTreeHandled?.valueOrThrow(); + this.#onFrameStartedLoading(event.frameId); + }); + session.on("Page.frameStoppedLoading", async (event) => { + await this.#frameTreeHandled?.valueOrThrow(); + this.#onFrameStoppedLoading(event.frameId); + }); + session.on("Runtime.executionContextCreated", async (event) => { + await this.#frameTreeHandled?.valueOrThrow(); + this.#onExecutionContextCreated(event.context, session); + }); + session.on("Page.lifecycleEvent", async (event) => { + await this.#frameTreeHandled?.valueOrThrow(); + this.#onLifecycleEvent(event); + }); + } + async initialize(client, frame) { + try { + this.#frameTreeHandled?.resolve(); + this.#frameTreeHandled = Deferred.create(); + await Promise.all([ + this.#networkManager.addClient(client), + client.send("Page.enable"), + client.send("Page.getFrameTree").then(({ frameTree }) => { + this.#handleFrameTree(client, frameTree); + this.#frameTreeHandled?.resolve(); + }), + client.send("Page.setLifecycleEventsEnabled", { enabled: true }), + client.send("Runtime.enable").then(() => { + return this.#createIsolatedWorld(client, UTILITY_WORLD_NAME); + }), + ...(frame ? Array.from(this.#scriptsToEvaluateOnNewDocument.values()) : []).map((script) => { + return frame?.addPreloadScript(script); + }), + ...(frame ? Array.from(this.#bindings.values()) : []).map((binding) => { + return frame?.addExposedFunctionBinding(binding); + }) + ]); + } catch (error) { + this.#frameTreeHandled?.resolve(); + if (isErrorLike(error) && isTargetClosedError(error)) { + return; + } + throw error; + } + } + page() { + return this.#page; + } + mainFrame() { + const mainFrame = this._frameTree.getMainFrame(); + assert(mainFrame, "Requesting main frame too early!"); + return mainFrame; + } + frames() { + return Array.from(this._frameTree.frames()); + } + frame(frameId) { + return this._frameTree.getById(frameId) || null; + } + async addExposedFunctionBinding(binding) { + this.#bindings.add(binding); + await Promise.all(this.frames().map(async (frame) => { + return await frame.addExposedFunctionBinding(binding); + })); + } + async removeExposedFunctionBinding(binding) { + this.#bindings.delete(binding); + await Promise.all(this.frames().map(async (frame) => { + return await frame.removeExposedFunctionBinding(binding); + })); + } + async evaluateOnNewDocument(source) { + const { identifier } = await this.mainFrame()._client().send("Page.addScriptToEvaluateOnNewDocument", { + source + }); + const preloadScript = new CdpPreloadScript(this.mainFrame(), identifier, source); + this.#scriptsToEvaluateOnNewDocument.set(identifier, preloadScript); + await Promise.all(this.frames().map(async (frame) => { + return await frame.addPreloadScript(preloadScript); + })); + return { identifier }; + } + async removeScriptToEvaluateOnNewDocument(identifier) { + const preloadScript = this.#scriptsToEvaluateOnNewDocument.get(identifier); + if (!preloadScript) { + throw new Error(`Script to evaluate on new document with id ${identifier} not found`); + } + this.#scriptsToEvaluateOnNewDocument.delete(identifier); + await Promise.all(this.frames().map((frame) => { + const identifier2 = preloadScript.getIdForFrame(frame); + if (!identifier2) { + return; + } + return frame._client().send("Page.removeScriptToEvaluateOnNewDocument", { + identifier: identifier2 + }).catch(debugError); + })); + } + onAttachedToTarget(target) { + if (target._getTargetInfo().type !== "iframe") { + return; + } + const frame = this.frame(target._getTargetInfo().targetId); + if (frame) { + frame.updateClient(target._session()); + } + this.setupEventListeners(target._session()); + void this.initialize(target._session(), frame); + } + _deviceRequestPromptManager(client) { + let manager = this.#deviceRequestPromptManagerMap.get(client); + if (manager === void 0) { + manager = new DeviceRequestPromptManager(client, this.#timeoutSettings); + this.#deviceRequestPromptManagerMap.set(client, manager); + } + return manager; + } + #onLifecycleEvent(event) { + const frame = this.frame(event.frameId); + if (!frame) { + return; + } + frame._onLifecycleEvent(event.loaderId, event.name); + this.emit(FrameManagerEvent.LifecycleEvent, frame); + frame.emit(FrameEvent.LifecycleEvent, void 0); + } + #onFrameStartedLoading(frameId) { + const frame = this.frame(frameId); + if (!frame) { + return; + } + frame._onLoadingStarted(); + } + #onFrameStoppedLoading(frameId) { + const frame = this.frame(frameId); + if (!frame) { + return; + } + frame._onLoadingStopped(); + this.emit(FrameManagerEvent.LifecycleEvent, frame); + frame.emit(FrameEvent.LifecycleEvent, void 0); + } + #handleFrameTree(session, frameTree) { + if (frameTree.frame.parentId) { + this.#onFrameAttached(session, frameTree.frame.id, frameTree.frame.parentId); + } + if (!this.#frameNavigatedReceived.has(frameTree.frame.id)) { + void this.#onFrameNavigated(frameTree.frame, "Navigation"); + } else { + this.#frameNavigatedReceived.delete(frameTree.frame.id); + } + if (!frameTree.childFrames) { + return; + } + for (const child of frameTree.childFrames) { + this.#handleFrameTree(session, child); + } + } + #onFrameAttached(session, frameId, parentFrameId) { + let frame = this.frame(frameId); + if (frame) { + const parentFrame = this.frame(parentFrameId); + if (session && parentFrame && frame.client !== parentFrame?.client) { + frame.updateClient(session); + } + return; + } + frame = new CdpFrame(this, frameId, parentFrameId, session); + this._frameTree.addFrame(frame); + this.emit(FrameManagerEvent.FrameAttached, frame); + } + async #onFrameNavigated(framePayload, navigationType) { + const frameId = framePayload.id; + const isMainFrame = !framePayload.parentId; + let frame = this._frameTree.getById(frameId); + if (frame) { + for (const child of frame.childFrames()) { + this.#removeFramesRecursively(child); + } + } + if (isMainFrame) { + if (frame) { + this._frameTree.removeFrame(frame); + frame._id = frameId; + } else { + frame = new CdpFrame(this, frameId, void 0, this.#client); + } + this._frameTree.addFrame(frame); + } + frame = await this._frameTree.waitForFrame(frameId); + frame._navigated(framePayload); + this.emit(FrameManagerEvent.FrameNavigated, frame); + frame.emit(FrameEvent.FrameNavigated, navigationType); + } + async #createIsolatedWorld(session, name) { + const key = `${session.id()}:${name}`; + if (this.#isolatedWorlds.has(key)) { + return; + } + await session.send("Page.addScriptToEvaluateOnNewDocument", { + source: `//# sourceURL=${PuppeteerURL.INTERNAL_URL}`, + worldName: name + }); + await Promise.all(this.frames().filter((frame) => { + return frame.client === session; + }).map((frame) => { + return session.send("Page.createIsolatedWorld", { + frameId: frame._id, + worldName: name, + grantUniveralAccess: true + }).catch(debugError); + })); + this.#isolatedWorlds.add(key); + } + #onFrameNavigatedWithinDocument(frameId, url) { + const frame = this.frame(frameId); + if (!frame) { + return; + } + frame._navigatedWithinDocument(url); + this.emit(FrameManagerEvent.FrameNavigatedWithinDocument, frame); + frame.emit(FrameEvent.FrameNavigatedWithinDocument, void 0); + this.emit(FrameManagerEvent.FrameNavigated, frame); + frame.emit(FrameEvent.FrameNavigated, "Navigation"); + } + #onFrameDetached(frameId, reason) { + const frame = this.frame(frameId); + if (!frame) { + return; + } + switch (reason) { + case "remove": + this.#removeFramesRecursively(frame); + break; + case "swap": + this.emit(FrameManagerEvent.FrameSwapped, frame); + frame.emit(FrameEvent.FrameSwapped, void 0); + break; + } + } + #onExecutionContextCreated(contextPayload, session) { + const auxData = contextPayload.auxData; + const frameId = auxData && auxData.frameId; + const frame = typeof frameId === "string" ? this.frame(frameId) : void 0; + let world; + if (frame) { + if (frame.client !== session) { + return; + } + if (contextPayload.auxData && contextPayload.auxData["isDefault"]) { + world = frame.worlds[MAIN_WORLD]; + } else if (contextPayload.name === UTILITY_WORLD_NAME) { + world = frame.worlds[PUPPETEER_WORLD]; + } + } + if (!world) { + return; + } + const context = new ExecutionContext(frame?.client || this.#client, contextPayload, world); + world.setContext(context); + } + #removeFramesRecursively(frame) { + for (const child of frame.childFrames()) { + this.#removeFramesRecursively(child); + } + frame[disposeSymbol](); + this._frameTree.removeFrame(frame); + this.emit(FrameManagerEvent.FrameDetached, frame); + frame.emit(FrameEvent.FrameDetached, frame); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Input.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/USKeyboardLayout.js +init_cjs_shim(); +var _keyDefinitions = { + "0": { keyCode: 48, key: "0", code: "Digit0" }, + "1": { keyCode: 49, key: "1", code: "Digit1" }, + "2": { keyCode: 50, key: "2", code: "Digit2" }, + "3": { keyCode: 51, key: "3", code: "Digit3" }, + "4": { keyCode: 52, key: "4", code: "Digit4" }, + "5": { keyCode: 53, key: "5", code: "Digit5" }, + "6": { keyCode: 54, key: "6", code: "Digit6" }, + "7": { keyCode: 55, key: "7", code: "Digit7" }, + "8": { keyCode: 56, key: "8", code: "Digit8" }, + "9": { keyCode: 57, key: "9", code: "Digit9" }, + Power: { key: "Power", code: "Power" }, + Eject: { key: "Eject", code: "Eject" }, + Abort: { keyCode: 3, code: "Abort", key: "Cancel" }, + Help: { keyCode: 6, code: "Help", key: "Help" }, + Backspace: { keyCode: 8, code: "Backspace", key: "Backspace" }, + Tab: { keyCode: 9, code: "Tab", key: "Tab" }, + Numpad5: { + keyCode: 12, + shiftKeyCode: 101, + key: "Clear", + code: "Numpad5", + shiftKey: "5", + location: 3 + }, + NumpadEnter: { + keyCode: 13, + code: "NumpadEnter", + key: "Enter", + text: "\r", + location: 3 + }, + Enter: { keyCode: 13, code: "Enter", key: "Enter", text: "\r" }, + "\r": { keyCode: 13, code: "Enter", key: "Enter", text: "\r" }, + "\n": { keyCode: 13, code: "Enter", key: "Enter", text: "\r" }, + ShiftLeft: { keyCode: 16, code: "ShiftLeft", key: "Shift", location: 1 }, + ShiftRight: { keyCode: 16, code: "ShiftRight", key: "Shift", location: 2 }, + ControlLeft: { + keyCode: 17, + code: "ControlLeft", + key: "Control", + location: 1 + }, + ControlRight: { + keyCode: 17, + code: "ControlRight", + key: "Control", + location: 2 + }, + AltLeft: { keyCode: 18, code: "AltLeft", key: "Alt", location: 1 }, + AltRight: { keyCode: 18, code: "AltRight", key: "Alt", location: 2 }, + Pause: { keyCode: 19, code: "Pause", key: "Pause" }, + CapsLock: { keyCode: 20, code: "CapsLock", key: "CapsLock" }, + Escape: { keyCode: 27, code: "Escape", key: "Escape" }, + Convert: { keyCode: 28, code: "Convert", key: "Convert" }, + NonConvert: { keyCode: 29, code: "NonConvert", key: "NonConvert" }, + Space: { keyCode: 32, code: "Space", key: " " }, + Numpad9: { + keyCode: 33, + shiftKeyCode: 105, + key: "PageUp", + code: "Numpad9", + shiftKey: "9", + location: 3 + }, + PageUp: { keyCode: 33, code: "PageUp", key: "PageUp" }, + Numpad3: { + keyCode: 34, + shiftKeyCode: 99, + key: "PageDown", + code: "Numpad3", + shiftKey: "3", + location: 3 + }, + PageDown: { keyCode: 34, code: "PageDown", key: "PageDown" }, + End: { keyCode: 35, code: "End", key: "End" }, + Numpad1: { + keyCode: 35, + shiftKeyCode: 97, + key: "End", + code: "Numpad1", + shiftKey: "1", + location: 3 + }, + Home: { keyCode: 36, code: "Home", key: "Home" }, + Numpad7: { + keyCode: 36, + shiftKeyCode: 103, + key: "Home", + code: "Numpad7", + shiftKey: "7", + location: 3 + }, + ArrowLeft: { keyCode: 37, code: "ArrowLeft", key: "ArrowLeft" }, + Numpad4: { + keyCode: 37, + shiftKeyCode: 100, + key: "ArrowLeft", + code: "Numpad4", + shiftKey: "4", + location: 3 + }, + Numpad8: { + keyCode: 38, + shiftKeyCode: 104, + key: "ArrowUp", + code: "Numpad8", + shiftKey: "8", + location: 3 + }, + ArrowUp: { keyCode: 38, code: "ArrowUp", key: "ArrowUp" }, + ArrowRight: { keyCode: 39, code: "ArrowRight", key: "ArrowRight" }, + Numpad6: { + keyCode: 39, + shiftKeyCode: 102, + key: "ArrowRight", + code: "Numpad6", + shiftKey: "6", + location: 3 + }, + Numpad2: { + keyCode: 40, + shiftKeyCode: 98, + key: "ArrowDown", + code: "Numpad2", + shiftKey: "2", + location: 3 + }, + ArrowDown: { keyCode: 40, code: "ArrowDown", key: "ArrowDown" }, + Select: { keyCode: 41, code: "Select", key: "Select" }, + Open: { keyCode: 43, code: "Open", key: "Execute" }, + PrintScreen: { keyCode: 44, code: "PrintScreen", key: "PrintScreen" }, + Insert: { keyCode: 45, code: "Insert", key: "Insert" }, + Numpad0: { + keyCode: 45, + shiftKeyCode: 96, + key: "Insert", + code: "Numpad0", + shiftKey: "0", + location: 3 + }, + Delete: { keyCode: 46, code: "Delete", key: "Delete" }, + NumpadDecimal: { + keyCode: 46, + shiftKeyCode: 110, + code: "NumpadDecimal", + key: "\0", + shiftKey: ".", + location: 3 + }, + Digit0: { keyCode: 48, code: "Digit0", shiftKey: ")", key: "0" }, + Digit1: { keyCode: 49, code: "Digit1", shiftKey: "!", key: "1" }, + Digit2: { keyCode: 50, code: "Digit2", shiftKey: "@", key: "2" }, + Digit3: { keyCode: 51, code: "Digit3", shiftKey: "#", key: "3" }, + Digit4: { keyCode: 52, code: "Digit4", shiftKey: "$", key: "4" }, + Digit5: { keyCode: 53, code: "Digit5", shiftKey: "%", key: "5" }, + Digit6: { keyCode: 54, code: "Digit6", shiftKey: "^", key: "6" }, + Digit7: { keyCode: 55, code: "Digit7", shiftKey: "&", key: "7" }, + Digit8: { keyCode: 56, code: "Digit8", shiftKey: "*", key: "8" }, + Digit9: { keyCode: 57, code: "Digit9", shiftKey: "(", key: "9" }, + KeyA: { keyCode: 65, code: "KeyA", shiftKey: "A", key: "a" }, + KeyB: { keyCode: 66, code: "KeyB", shiftKey: "B", key: "b" }, + KeyC: { keyCode: 67, code: "KeyC", shiftKey: "C", key: "c" }, + KeyD: { keyCode: 68, code: "KeyD", shiftKey: "D", key: "d" }, + KeyE: { keyCode: 69, code: "KeyE", shiftKey: "E", key: "e" }, + KeyF: { keyCode: 70, code: "KeyF", shiftKey: "F", key: "f" }, + KeyG: { keyCode: 71, code: "KeyG", shiftKey: "G", key: "g" }, + KeyH: { keyCode: 72, code: "KeyH", shiftKey: "H", key: "h" }, + KeyI: { keyCode: 73, code: "KeyI", shiftKey: "I", key: "i" }, + KeyJ: { keyCode: 74, code: "KeyJ", shiftKey: "J", key: "j" }, + KeyK: { keyCode: 75, code: "KeyK", shiftKey: "K", key: "k" }, + KeyL: { keyCode: 76, code: "KeyL", shiftKey: "L", key: "l" }, + KeyM: { keyCode: 77, code: "KeyM", shiftKey: "M", key: "m" }, + KeyN: { keyCode: 78, code: "KeyN", shiftKey: "N", key: "n" }, + KeyO: { keyCode: 79, code: "KeyO", shiftKey: "O", key: "o" }, + KeyP: { keyCode: 80, code: "KeyP", shiftKey: "P", key: "p" }, + KeyQ: { keyCode: 81, code: "KeyQ", shiftKey: "Q", key: "q" }, + KeyR: { keyCode: 82, code: "KeyR", shiftKey: "R", key: "r" }, + KeyS: { keyCode: 83, code: "KeyS", shiftKey: "S", key: "s" }, + KeyT: { keyCode: 84, code: "KeyT", shiftKey: "T", key: "t" }, + KeyU: { keyCode: 85, code: "KeyU", shiftKey: "U", key: "u" }, + KeyV: { keyCode: 86, code: "KeyV", shiftKey: "V", key: "v" }, + KeyW: { keyCode: 87, code: "KeyW", shiftKey: "W", key: "w" }, + KeyX: { keyCode: 88, code: "KeyX", shiftKey: "X", key: "x" }, + KeyY: { keyCode: 89, code: "KeyY", shiftKey: "Y", key: "y" }, + KeyZ: { keyCode: 90, code: "KeyZ", shiftKey: "Z", key: "z" }, + MetaLeft: { keyCode: 91, code: "MetaLeft", key: "Meta", location: 1 }, + MetaRight: { keyCode: 92, code: "MetaRight", key: "Meta", location: 2 }, + ContextMenu: { keyCode: 93, code: "ContextMenu", key: "ContextMenu" }, + NumpadMultiply: { + keyCode: 106, + code: "NumpadMultiply", + key: "*", + location: 3 + }, + NumpadAdd: { keyCode: 107, code: "NumpadAdd", key: "+", location: 3 }, + NumpadSubtract: { + keyCode: 109, + code: "NumpadSubtract", + key: "-", + location: 3 + }, + NumpadDivide: { keyCode: 111, code: "NumpadDivide", key: "/", location: 3 }, + F1: { keyCode: 112, code: "F1", key: "F1" }, + F2: { keyCode: 113, code: "F2", key: "F2" }, + F3: { keyCode: 114, code: "F3", key: "F3" }, + F4: { keyCode: 115, code: "F4", key: "F4" }, + F5: { keyCode: 116, code: "F5", key: "F5" }, + F6: { keyCode: 117, code: "F6", key: "F6" }, + F7: { keyCode: 118, code: "F7", key: "F7" }, + F8: { keyCode: 119, code: "F8", key: "F8" }, + F9: { keyCode: 120, code: "F9", key: "F9" }, + F10: { keyCode: 121, code: "F10", key: "F10" }, + F11: { keyCode: 122, code: "F11", key: "F11" }, + F12: { keyCode: 123, code: "F12", key: "F12" }, + F13: { keyCode: 124, code: "F13", key: "F13" }, + F14: { keyCode: 125, code: "F14", key: "F14" }, + F15: { keyCode: 126, code: "F15", key: "F15" }, + F16: { keyCode: 127, code: "F16", key: "F16" }, + F17: { keyCode: 128, code: "F17", key: "F17" }, + F18: { keyCode: 129, code: "F18", key: "F18" }, + F19: { keyCode: 130, code: "F19", key: "F19" }, + F20: { keyCode: 131, code: "F20", key: "F20" }, + F21: { keyCode: 132, code: "F21", key: "F21" }, + F22: { keyCode: 133, code: "F22", key: "F22" }, + F23: { keyCode: 134, code: "F23", key: "F23" }, + F24: { keyCode: 135, code: "F24", key: "F24" }, + NumLock: { keyCode: 144, code: "NumLock", key: "NumLock" }, + ScrollLock: { keyCode: 145, code: "ScrollLock", key: "ScrollLock" }, + AudioVolumeMute: { + keyCode: 173, + code: "AudioVolumeMute", + key: "AudioVolumeMute" + }, + AudioVolumeDown: { + keyCode: 174, + code: "AudioVolumeDown", + key: "AudioVolumeDown" + }, + AudioVolumeUp: { keyCode: 175, code: "AudioVolumeUp", key: "AudioVolumeUp" }, + MediaTrackNext: { + keyCode: 176, + code: "MediaTrackNext", + key: "MediaTrackNext" + }, + MediaTrackPrevious: { + keyCode: 177, + code: "MediaTrackPrevious", + key: "MediaTrackPrevious" + }, + MediaStop: { keyCode: 178, code: "MediaStop", key: "MediaStop" }, + MediaPlayPause: { + keyCode: 179, + code: "MediaPlayPause", + key: "MediaPlayPause" + }, + Semicolon: { keyCode: 186, code: "Semicolon", shiftKey: ":", key: ";" }, + Equal: { keyCode: 187, code: "Equal", shiftKey: "+", key: "=" }, + NumpadEqual: { keyCode: 187, code: "NumpadEqual", key: "=", location: 3 }, + Comma: { keyCode: 188, code: "Comma", shiftKey: "<", key: "," }, + Minus: { keyCode: 189, code: "Minus", shiftKey: "_", key: "-" }, + Period: { keyCode: 190, code: "Period", shiftKey: ">", key: "." }, + Slash: { keyCode: 191, code: "Slash", shiftKey: "?", key: "/" }, + Backquote: { keyCode: 192, code: "Backquote", shiftKey: "~", key: "`" }, + BracketLeft: { keyCode: 219, code: "BracketLeft", shiftKey: "{", key: "[" }, + Backslash: { keyCode: 220, code: "Backslash", shiftKey: "|", key: "\\" }, + BracketRight: { keyCode: 221, code: "BracketRight", shiftKey: "}", key: "]" }, + Quote: { keyCode: 222, code: "Quote", shiftKey: '"', key: "'" }, + AltGraph: { keyCode: 225, code: "AltGraph", key: "AltGraph" }, + Props: { keyCode: 247, code: "Props", key: "CrSel" }, + Cancel: { keyCode: 3, key: "Cancel", code: "Abort" }, + Clear: { keyCode: 12, key: "Clear", code: "Numpad5", location: 3 }, + Shift: { keyCode: 16, key: "Shift", code: "ShiftLeft", location: 1 }, + Control: { keyCode: 17, key: "Control", code: "ControlLeft", location: 1 }, + Alt: { keyCode: 18, key: "Alt", code: "AltLeft", location: 1 }, + Accept: { keyCode: 30, key: "Accept" }, + ModeChange: { keyCode: 31, key: "ModeChange" }, + " ": { keyCode: 32, key: " ", code: "Space" }, + Print: { keyCode: 42, key: "Print" }, + Execute: { keyCode: 43, key: "Execute", code: "Open" }, + "\0": { keyCode: 46, key: "\0", code: "NumpadDecimal", location: 3 }, + a: { keyCode: 65, key: "a", code: "KeyA" }, + b: { keyCode: 66, key: "b", code: "KeyB" }, + c: { keyCode: 67, key: "c", code: "KeyC" }, + d: { keyCode: 68, key: "d", code: "KeyD" }, + e: { keyCode: 69, key: "e", code: "KeyE" }, + f: { keyCode: 70, key: "f", code: "KeyF" }, + g: { keyCode: 71, key: "g", code: "KeyG" }, + h: { keyCode: 72, key: "h", code: "KeyH" }, + i: { keyCode: 73, key: "i", code: "KeyI" }, + j: { keyCode: 74, key: "j", code: "KeyJ" }, + k: { keyCode: 75, key: "k", code: "KeyK" }, + l: { keyCode: 76, key: "l", code: "KeyL" }, + m: { keyCode: 77, key: "m", code: "KeyM" }, + n: { keyCode: 78, key: "n", code: "KeyN" }, + o: { keyCode: 79, key: "o", code: "KeyO" }, + p: { keyCode: 80, key: "p", code: "KeyP" }, + q: { keyCode: 81, key: "q", code: "KeyQ" }, + r: { keyCode: 82, key: "r", code: "KeyR" }, + s: { keyCode: 83, key: "s", code: "KeyS" }, + t: { keyCode: 84, key: "t", code: "KeyT" }, + u: { keyCode: 85, key: "u", code: "KeyU" }, + v: { keyCode: 86, key: "v", code: "KeyV" }, + w: { keyCode: 87, key: "w", code: "KeyW" }, + x: { keyCode: 88, key: "x", code: "KeyX" }, + y: { keyCode: 89, key: "y", code: "KeyY" }, + z: { keyCode: 90, key: "z", code: "KeyZ" }, + Meta: { keyCode: 91, key: "Meta", code: "MetaLeft", location: 1 }, + "*": { keyCode: 106, key: "*", code: "NumpadMultiply", location: 3 }, + "+": { keyCode: 107, key: "+", code: "NumpadAdd", location: 3 }, + "-": { keyCode: 109, key: "-", code: "NumpadSubtract", location: 3 }, + "/": { keyCode: 111, key: "/", code: "NumpadDivide", location: 3 }, + ";": { keyCode: 186, key: ";", code: "Semicolon" }, + "=": { keyCode: 187, key: "=", code: "Equal" }, + ",": { keyCode: 188, key: ",", code: "Comma" }, + ".": { keyCode: 190, key: ".", code: "Period" }, + "`": { keyCode: 192, key: "`", code: "Backquote" }, + "[": { keyCode: 219, key: "[", code: "BracketLeft" }, + "\\": { keyCode: 220, key: "\\", code: "Backslash" }, + "]": { keyCode: 221, key: "]", code: "BracketRight" }, + "'": { keyCode: 222, key: "'", code: "Quote" }, + Attn: { keyCode: 246, key: "Attn" }, + CrSel: { keyCode: 247, key: "CrSel", code: "Props" }, + ExSel: { keyCode: 248, key: "ExSel" }, + EraseEof: { keyCode: 249, key: "EraseEof" }, + Play: { keyCode: 250, key: "Play" }, + ZoomOut: { keyCode: 251, key: "ZoomOut" }, + ")": { keyCode: 48, key: ")", code: "Digit0" }, + "!": { keyCode: 49, key: "!", code: "Digit1" }, + "@": { keyCode: 50, key: "@", code: "Digit2" }, + "#": { keyCode: 51, key: "#", code: "Digit3" }, + $: { keyCode: 52, key: "$", code: "Digit4" }, + "%": { keyCode: 53, key: "%", code: "Digit5" }, + "^": { keyCode: 54, key: "^", code: "Digit6" }, + "&": { keyCode: 55, key: "&", code: "Digit7" }, + "(": { keyCode: 57, key: "(", code: "Digit9" }, + A: { keyCode: 65, key: "A", code: "KeyA" }, + B: { keyCode: 66, key: "B", code: "KeyB" }, + C: { keyCode: 67, key: "C", code: "KeyC" }, + D: { keyCode: 68, key: "D", code: "KeyD" }, + E: { keyCode: 69, key: "E", code: "KeyE" }, + F: { keyCode: 70, key: "F", code: "KeyF" }, + G: { keyCode: 71, key: "G", code: "KeyG" }, + H: { keyCode: 72, key: "H", code: "KeyH" }, + I: { keyCode: 73, key: "I", code: "KeyI" }, + J: { keyCode: 74, key: "J", code: "KeyJ" }, + K: { keyCode: 75, key: "K", code: "KeyK" }, + L: { keyCode: 76, key: "L", code: "KeyL" }, + M: { keyCode: 77, key: "M", code: "KeyM" }, + N: { keyCode: 78, key: "N", code: "KeyN" }, + O: { keyCode: 79, key: "O", code: "KeyO" }, + P: { keyCode: 80, key: "P", code: "KeyP" }, + Q: { keyCode: 81, key: "Q", code: "KeyQ" }, + R: { keyCode: 82, key: "R", code: "KeyR" }, + S: { keyCode: 83, key: "S", code: "KeyS" }, + T: { keyCode: 84, key: "T", code: "KeyT" }, + U: { keyCode: 85, key: "U", code: "KeyU" }, + V: { keyCode: 86, key: "V", code: "KeyV" }, + W: { keyCode: 87, key: "W", code: "KeyW" }, + X: { keyCode: 88, key: "X", code: "KeyX" }, + Y: { keyCode: 89, key: "Y", code: "KeyY" }, + Z: { keyCode: 90, key: "Z", code: "KeyZ" }, + ":": { keyCode: 186, key: ":", code: "Semicolon" }, + "<": { keyCode: 188, key: "<", code: "Comma" }, + _: { keyCode: 189, key: "_", code: "Minus" }, + ">": { keyCode: 190, key: ">", code: "Period" }, + "?": { keyCode: 191, key: "?", code: "Slash" }, + "~": { keyCode: 192, key: "~", code: "Backquote" }, + "{": { keyCode: 219, key: "{", code: "BracketLeft" }, + "|": { keyCode: 220, key: "|", code: "Backslash" }, + "}": { keyCode: 221, key: "}", code: "BracketRight" }, + '"': { keyCode: 222, key: '"', code: "Quote" }, + SoftLeft: { key: "SoftLeft", code: "SoftLeft", location: 4 }, + SoftRight: { key: "SoftRight", code: "SoftRight", location: 4 }, + Camera: { keyCode: 44, key: "Camera", code: "Camera", location: 4 }, + Call: { key: "Call", code: "Call", location: 4 }, + EndCall: { keyCode: 95, key: "EndCall", code: "EndCall", location: 4 }, + VolumeDown: { + keyCode: 182, + key: "VolumeDown", + code: "VolumeDown", + location: 4 + }, + VolumeUp: { keyCode: 183, key: "VolumeUp", code: "VolumeUp", location: 4 } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Input.js +var CdpKeyboard = class extends Keyboard { + #client; + #pressedKeys = /* @__PURE__ */ new Set(); + _modifiers = 0; + constructor(client) { + super(); + this.#client = client; + } + updateClient(client) { + this.#client = client; + } + async down(key, options = { + text: void 0, + commands: [] + }) { + const description = this.#keyDescriptionForString(key); + const autoRepeat = this.#pressedKeys.has(description.code); + this.#pressedKeys.add(description.code); + this._modifiers |= this.#modifierBit(description.key); + const text = options.text === void 0 ? description.text : options.text; + await this.#client.send("Input.dispatchKeyEvent", { + type: text ? "keyDown" : "rawKeyDown", + modifiers: this._modifiers, + windowsVirtualKeyCode: description.keyCode, + code: description.code, + key: description.key, + text, + unmodifiedText: text, + autoRepeat, + location: description.location, + isKeypad: description.location === 3, + commands: options.commands + }); + } + #modifierBit(key) { + if (key === "Alt") { + return 1; + } + if (key === "Control") { + return 2; + } + if (key === "Meta") { + return 4; + } + if (key === "Shift") { + return 8; + } + return 0; + } + #keyDescriptionForString(keyString) { + const shift = this._modifiers & 8; + const description = { + key: "", + keyCode: 0, + code: "", + text: "", + location: 0 + }; + const definition = _keyDefinitions[keyString]; + assert(definition, `Unknown key: "${keyString}"`); + if (definition.key) { + description.key = definition.key; + } + if (shift && definition.shiftKey) { + description.key = definition.shiftKey; + } + if (definition.keyCode) { + description.keyCode = definition.keyCode; + } + if (shift && definition.shiftKeyCode) { + description.keyCode = definition.shiftKeyCode; + } + if (definition.code) { + description.code = definition.code; + } + if (definition.location) { + description.location = definition.location; + } + if (description.key.length === 1) { + description.text = description.key; + } + if (definition.text) { + description.text = definition.text; + } + if (shift && definition.shiftText) { + description.text = definition.shiftText; + } + if (this._modifiers & ~8) { + description.text = ""; + } + return description; + } + async up(key) { + const description = this.#keyDescriptionForString(key); + this._modifiers &= ~this.#modifierBit(description.key); + this.#pressedKeys.delete(description.code); + await this.#client.send("Input.dispatchKeyEvent", { + type: "keyUp", + modifiers: this._modifiers, + key: description.key, + windowsVirtualKeyCode: description.keyCode, + code: description.code, + location: description.location + }); + } + async sendCharacter(char) { + await this.#client.send("Input.insertText", { text: char }); + } + charIsKey(char) { + return !!_keyDefinitions[char]; + } + async type(text, options = {}) { + const delay = options.delay || void 0; + for (const char of text) { + if (this.charIsKey(char)) { + await this.press(char, { delay }); + } else { + if (delay) { + await new Promise((f) => { + return setTimeout(f, delay); + }); + } + await this.sendCharacter(char); + } + } + } + async press(key, options = {}) { + const { delay = null } = options; + await this.down(key, options); + if (delay) { + await new Promise((f) => { + return setTimeout(f, options.delay); + }); + } + await this.up(key); + } +}; +var getFlag = (button) => { + switch (button) { + case MouseButton.Left: + return 1; + case MouseButton.Right: + return 2; + case MouseButton.Middle: + return 4; + case MouseButton.Back: + return 8; + case MouseButton.Forward: + return 16; + } +}; +var getButtonFromPressedButtons = (buttons) => { + if (buttons & 1) { + return MouseButton.Left; + } else if (buttons & 2) { + return MouseButton.Right; + } else if (buttons & 4) { + return MouseButton.Middle; + } else if (buttons & 8) { + return MouseButton.Back; + } else if (buttons & 16) { + return MouseButton.Forward; + } + return "none"; +}; +var CdpMouse = class extends Mouse { + #client; + #keyboard; + constructor(client, keyboard) { + super(); + this.#client = client; + this.#keyboard = keyboard; + } + updateClient(client) { + this.#client = client; + } + #_state = { + position: { x: 0, y: 0 }, + buttons: 0 + }; + get #state() { + return Object.assign({ ...this.#_state }, ...this.#transactions); + } + // Transactions can run in parallel, so we store each of thme in this array. + #transactions = []; + #createTransaction() { + const transaction = {}; + this.#transactions.push(transaction); + const popTransaction = () => { + this.#transactions.splice(this.#transactions.indexOf(transaction), 1); + }; + return { + update: (updates) => { + Object.assign(transaction, updates); + }, + commit: () => { + this.#_state = { ...this.#_state, ...transaction }; + popTransaction(); + }, + rollback: popTransaction + }; + } + /** + * This is a shortcut for a typical update, commit/rollback lifecycle based on + * the error of the action. + */ + async #withTransaction(action) { + const { update, commit, rollback } = this.#createTransaction(); + try { + await action(update); + commit(); + } catch (error) { + rollback(); + throw error; + } + } + async reset() { + const actions = []; + for (const [flag, button] of [ + [1, MouseButton.Left], + [4, MouseButton.Middle], + [2, MouseButton.Right], + [16, MouseButton.Forward], + [8, MouseButton.Back] + ]) { + if (this.#state.buttons & flag) { + actions.push(this.up({ button })); + } + } + if (this.#state.position.x !== 0 || this.#state.position.y !== 0) { + actions.push(this.move(0, 0)); + } + await Promise.all(actions); + } + async move(x, y, options = {}) { + const { steps = 1 } = options; + const from2 = this.#state.position; + const to = { x, y }; + for (let i = 1; i <= steps; i++) { + await this.#withTransaction((updateState) => { + updateState({ + position: { + x: from2.x + (to.x - from2.x) * (i / steps), + y: from2.y + (to.y - from2.y) * (i / steps) + } + }); + const { buttons, position } = this.#state; + return this.#client.send("Input.dispatchMouseEvent", { + type: "mouseMoved", + modifiers: this.#keyboard._modifiers, + buttons, + button: getButtonFromPressedButtons(buttons), + ...position + }); + }); + } + } + async down(options = {}) { + const { button = MouseButton.Left, clickCount = 1 } = options; + const flag = getFlag(button); + if (!flag) { + throw new Error(`Unsupported mouse button: ${button}`); + } + if (this.#state.buttons & flag) { + throw new Error(`'${button}' is already pressed.`); + } + await this.#withTransaction((updateState) => { + updateState({ + buttons: this.#state.buttons | flag + }); + const { buttons, position } = this.#state; + return this.#client.send("Input.dispatchMouseEvent", { + type: "mousePressed", + modifiers: this.#keyboard._modifiers, + clickCount, + buttons, + button, + ...position + }); + }); + } + async up(options = {}) { + const { button = MouseButton.Left, clickCount = 1 } = options; + const flag = getFlag(button); + if (!flag) { + throw new Error(`Unsupported mouse button: ${button}`); + } + if (!(this.#state.buttons & flag)) { + throw new Error(`'${button}' is not pressed.`); + } + await this.#withTransaction((updateState) => { + updateState({ + buttons: this.#state.buttons & ~flag + }); + const { buttons, position } = this.#state; + return this.#client.send("Input.dispatchMouseEvent", { + type: "mouseReleased", + modifiers: this.#keyboard._modifiers, + clickCount, + buttons, + button, + ...position + }); + }); + } + async click(x, y, options = {}) { + const { delay, count = 1, clickCount = count } = options; + if (count < 1) { + throw new Error("Click must occur a positive number of times."); + } + const actions = [this.move(x, y)]; + if (clickCount === count) { + for (let i = 1; i < count; ++i) { + actions.push(this.down({ ...options, clickCount: i }), this.up({ ...options, clickCount: i })); + } + } + actions.push(this.down({ ...options, clickCount })); + if (typeof delay === "number") { + await Promise.all(actions); + actions.length = 0; + await new Promise((resolve5) => { + setTimeout(resolve5, delay); + }); + } + actions.push(this.up({ ...options, clickCount })); + await Promise.all(actions); + } + async wheel(options = {}) { + const { deltaX = 0, deltaY = 0 } = options; + const { position, buttons } = this.#state; + await this.#client.send("Input.dispatchMouseEvent", { + type: "mouseWheel", + pointerType: "mouse", + modifiers: this.#keyboard._modifiers, + deltaY, + deltaX, + buttons, + ...position + }); + } + async drag(start, target) { + const promise = new Promise((resolve5) => { + this.#client.once("Input.dragIntercepted", (event) => { + return resolve5(event.data); + }); + }); + await this.move(start.x, start.y); + await this.down(); + await this.move(target.x, target.y); + return await promise; + } + async dragEnter(target, data) { + await this.#client.send("Input.dispatchDragEvent", { + type: "dragEnter", + x: target.x, + y: target.y, + modifiers: this.#keyboard._modifiers, + data + }); + } + async dragOver(target, data) { + await this.#client.send("Input.dispatchDragEvent", { + type: "dragOver", + x: target.x, + y: target.y, + modifiers: this.#keyboard._modifiers, + data + }); + } + async drop(target, data) { + await this.#client.send("Input.dispatchDragEvent", { + type: "drop", + x: target.x, + y: target.y, + modifiers: this.#keyboard._modifiers, + data + }); + } + async dragAndDrop(start, target, options = {}) { + const { delay = null } = options; + const data = await this.drag(start, target); + await this.dragEnter(target, data); + await this.dragOver(target, data); + if (delay) { + await new Promise((resolve5) => { + return setTimeout(resolve5, delay); + }); + } + await this.drop(target, data); + await this.up(); + } +}; +var CdpTouchHandle = class { + #started = false; + #touchScreen; + #touchPoint; + #client; + #keyboard; + constructor(client, touchScreen, keyboard, touchPoint) { + this.#client = client; + this.#touchScreen = touchScreen; + this.#keyboard = keyboard; + this.#touchPoint = touchPoint; + } + updateClient(client) { + this.#client = client; + } + async start() { + if (this.#started) { + throw new TouchError("Touch has already started"); + } + await this.#client.send("Input.dispatchTouchEvent", { + type: "touchStart", + touchPoints: [this.#touchPoint], + modifiers: this.#keyboard._modifiers + }); + this.#started = true; + } + move(x, y) { + this.#touchPoint.x = Math.round(x); + this.#touchPoint.y = Math.round(y); + return this.#client.send("Input.dispatchTouchEvent", { + type: "touchMove", + touchPoints: [this.#touchPoint], + modifiers: this.#keyboard._modifiers + }); + } + async end() { + await this.#client.send("Input.dispatchTouchEvent", { + type: "touchEnd", + touchPoints: [this.#touchPoint], + modifiers: this.#keyboard._modifiers + }); + this.#touchScreen.removeHandle(this); + } +}; +var CdpTouchscreen = class extends Touchscreen { + #client; + #keyboard; + constructor(client, keyboard) { + super(); + this.#client = client; + this.#keyboard = keyboard; + } + updateClient(client) { + this.#client = client; + this.touches.forEach((t) => { + t.updateClient(client); + }); + } + async touchStart(x, y) { + const id = this.idGenerator(); + const touchPoint = { + x: Math.round(x), + y: Math.round(y), + radiusX: 0.5, + radiusY: 0.5, + force: 0.5, + id + }; + const touch = new CdpTouchHandle(this.#client, this, this.#keyboard, touchPoint); + await touch.start(); + this.touches.push(touch); + return touch; + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/WebWorker.js +init_cjs_shim(); +var CdpWebWorker = class extends WebWorker { + #world; + #client; + #id; + #targetType; + constructor(client, url, targetId, targetType, consoleAPICalled, exceptionThrown) { + super(url); + this.#id = targetId; + this.#client = client; + this.#targetType = targetType; + this.#world = new IsolatedWorld(this, new TimeoutSettings()); + this.#client.once("Runtime.executionContextCreated", async (event) => { + this.#world.setContext(new ExecutionContext(client, event.context, this.#world)); + }); + this.#world.emitter.on("consoleapicalled", async (event) => { + try { + return consoleAPICalled(event.type, event.args.map((object) => { + return new CdpJSHandle(this.#world, object); + }), event.stackTrace); + } catch (err) { + debugError(err); + } + }); + this.#client.on("Runtime.exceptionThrown", exceptionThrown); + this.#client.once(CDPSessionEvent.Disconnected, () => { + this.#world.dispose(); + }); + this.#client.send("Runtime.enable").catch(debugError); + } + mainRealm() { + return this.#world; + } + get client() { + return this.#client; + } + async close() { + switch (this.#targetType) { + case TargetType.SERVICE_WORKER: + case TargetType.SHARED_WORKER: { + await this.client.connection()?.send("Target.closeTarget", { + targetId: this.#id + }); + await this.client.connection()?.send("Target.detachFromTarget", { + sessionId: this.client.id() + }); + break; + } + default: + await this.evaluate(() => { + self.close(); + }); + } + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Page.js +var __addDisposableResource4 = function(env2, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env2.stack.push({ value, dispose, async }); + } else if (async) { + env2.stack.push({ async: true }); + } + return value; +}; +var __disposeResources4 = function(SuppressedError2) { + return function(env2) { + function fail(e) { + env2.error = env2.hasError ? new SuppressedError2(e, env2.error, "An error was suppressed during disposal.") : e; + env2.hasError = true; + } + var r, s = 0; + function next() { + while (r = env2.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env2.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env2.hasError ? Promise.reject(env2.error) : Promise.resolve(); + if (env2.hasError) + throw env2.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +function convertConsoleMessageLevel(method) { + switch (method) { + case "warning": + return "warn"; + default: + return method; + } +} +var CdpPage = class extends Page { + static async _create(client, target, defaultViewport) { + const page = new CdpPage(client, target); + await page.#initialize(); + if (defaultViewport) { + try { + await page.setViewport(defaultViewport); + } catch (err) { + if (isErrorLike(err) && isTargetClosedError(err)) { + debugError(err); + } else { + throw err; + } + } + } + return page; + } + #closed = false; + #targetManager; + #primaryTargetClient; + #primaryTarget; + #tabTargetClient; + #tabTarget; + #keyboard; + #mouse; + #touchscreen; + #frameManager; + #emulationManager; + #tracing; + #bindings = /* @__PURE__ */ new Map(); + #exposedFunctions = /* @__PURE__ */ new Map(); + #coverage; + #viewport; + #workers = /* @__PURE__ */ new Map(); + #fileChooserDeferreds = /* @__PURE__ */ new Set(); + #sessionCloseDeferred = Deferred.create(); + #serviceWorkerBypassed = false; + #userDragInterceptionEnabled = false; + constructor(client, target) { + super(); + this.#primaryTargetClient = client; + this.#tabTargetClient = client.parentSession(); + assert(this.#tabTargetClient, "Tab target session is not defined."); + this.#tabTarget = this.#tabTargetClient._target(); + assert(this.#tabTarget, "Tab target is not defined."); + this.#primaryTarget = target; + this.#targetManager = target._targetManager(); + this.#keyboard = new CdpKeyboard(client); + this.#mouse = new CdpMouse(client, this.#keyboard); + this.#touchscreen = new CdpTouchscreen(client, this.#keyboard); + this.#frameManager = new FrameManager(client, this, this._timeoutSettings); + this.#emulationManager = new EmulationManager(client); + this.#tracing = new Tracing(client); + this.#coverage = new Coverage(client); + this.#viewport = null; + const frameManagerEmitter = new EventEmitter(this.#frameManager); + frameManagerEmitter.on(FrameManagerEvent.FrameAttached, (frame) => { + this.emit("frameattached", frame); + }); + frameManagerEmitter.on(FrameManagerEvent.FrameDetached, (frame) => { + this.emit("framedetached", frame); + }); + frameManagerEmitter.on(FrameManagerEvent.FrameNavigated, (frame) => { + this.emit("framenavigated", frame); + }); + frameManagerEmitter.on(FrameManagerEvent.ConsoleApiCalled, ([world, event]) => { + this.#onConsoleAPI(world, event); + }); + frameManagerEmitter.on(FrameManagerEvent.BindingCalled, ([world, event]) => { + void this.#onBindingCalled(world, event); + }); + const networkManagerEmitter = new EventEmitter(this.#frameManager.networkManager); + networkManagerEmitter.on(NetworkManagerEvent.Request, (request3) => { + this.emit("request", request3); + }); + networkManagerEmitter.on(NetworkManagerEvent.RequestServedFromCache, (request3) => { + this.emit("requestservedfromcache", request3); + }); + networkManagerEmitter.on(NetworkManagerEvent.Response, (response) => { + this.emit("response", response); + }); + networkManagerEmitter.on(NetworkManagerEvent.RequestFailed, (request3) => { + this.emit("requestfailed", request3); + }); + networkManagerEmitter.on(NetworkManagerEvent.RequestFinished, (request3) => { + this.emit("requestfinished", request3); + }); + this.#tabTargetClient.on(CDPSessionEvent.Swapped, this.#onActivation.bind(this)); + this.#tabTargetClient.on(CDPSessionEvent.Ready, this.#onSecondaryTarget.bind(this)); + this.#targetManager.on("targetGone", this.#onDetachedFromTarget); + this.#tabTarget._isClosedDeferred.valueOrThrow().then(() => { + this.#targetManager.off("targetGone", this.#onDetachedFromTarget); + this.emit("close", void 0); + this.#closed = true; + }).catch(debugError); + this.#setupPrimaryTargetListeners(); + this.#attachExistingTargets(); + } + #attachExistingTargets() { + const queue = []; + for (const childTarget of this.#targetManager.getChildTargets(this.#primaryTarget)) { + queue.push(childTarget); + } + let idx = 0; + while (idx < queue.length) { + const next = queue[idx]; + idx++; + const session = next._session(); + if (session) { + this.#onAttachedToTarget(session); + } + for (const childTarget of this.#targetManager.getChildTargets(next)) { + queue.push(childTarget); + } + } + } + async #onActivation(newSession) { + this.#primaryTargetClient = newSession; + assert(this.#primaryTargetClient instanceof CdpCDPSession, "CDPSession is not instance of CDPSessionImpl"); + this.#primaryTarget = this.#primaryTargetClient._target(); + assert(this.#primaryTarget, "Missing target on swap"); + this.#keyboard.updateClient(newSession); + this.#mouse.updateClient(newSession); + this.#touchscreen.updateClient(newSession); + this.#emulationManager.updateClient(newSession); + this.#tracing.updateClient(newSession); + this.#coverage.updateClient(newSession); + await this.#frameManager.swapFrameTree(newSession); + this.#setupPrimaryTargetListeners(); + } + async #onSecondaryTarget(session) { + assert(session instanceof CdpCDPSession); + if (session._target()._subtype() !== "prerender") { + return; + } + this.#frameManager.registerSpeculativeSession(session).catch(debugError); + this.#emulationManager.registerSpeculativeSession(session).catch(debugError); + } + /** + * Sets up listeners for the primary target. The primary target can change + * during a navigation to a prerended page. + */ + #setupPrimaryTargetListeners() { + const clientEmitter = new EventEmitter(this.#primaryTargetClient); + clientEmitter.on(CDPSessionEvent.Ready, this.#onAttachedToTarget); + clientEmitter.on(CDPSessionEvent.Disconnected, () => { + this.#sessionCloseDeferred.reject(new TargetCloseError("Target closed")); + }); + clientEmitter.on("Page.domContentEventFired", () => { + this.emit("domcontentloaded", void 0); + }); + clientEmitter.on("Page.loadEventFired", () => { + this.emit("load", void 0); + }); + clientEmitter.on("Page.javascriptDialogOpening", this.#onDialog.bind(this)); + clientEmitter.on("Runtime.exceptionThrown", this.#handleException.bind(this)); + clientEmitter.on("Inspector.targetCrashed", this.#onTargetCrashed.bind(this)); + clientEmitter.on("Performance.metrics", this.#emitMetrics.bind(this)); + clientEmitter.on("Log.entryAdded", this.#onLogEntryAdded.bind(this)); + clientEmitter.on("Page.fileChooserOpened", this.#onFileChooser.bind(this)); + } + #onDetachedFromTarget = (target) => { + const sessionId = target._session()?.id(); + const worker = this.#workers.get(sessionId); + if (!worker) { + return; + } + this.#workers.delete(sessionId); + this.emit("workerdestroyed", worker); + }; + #onAttachedToTarget = (session) => { + assert(session instanceof CdpCDPSession); + this.#frameManager.onAttachedToTarget(session._target()); + if (session._target()._getTargetInfo().type === "worker") { + const worker = new CdpWebWorker(session, session._target().url(), session._target()._targetId, session._target().type(), this.#addConsoleMessage.bind(this), this.#handleException.bind(this)); + this.#workers.set(session.id(), worker); + this.emit("workercreated", worker); + } + session.on(CDPSessionEvent.Ready, this.#onAttachedToTarget); + }; + async #initialize() { + try { + await Promise.all([ + this.#frameManager.initialize(this.#primaryTargetClient), + this.#primaryTargetClient.send("Performance.enable"), + this.#primaryTargetClient.send("Log.enable") + ]); + } catch (err) { + if (isErrorLike(err) && isTargetClosedError(err)) { + debugError(err); + } else { + throw err; + } + } + } + async #onFileChooser(event) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + if (!this.#fileChooserDeferreds.size) { + return; + } + const frame = this.#frameManager.frame(event.frameId); + assert(frame, "This should never happen."); + const handle = __addDisposableResource4(env_1, await frame.worlds[MAIN_WORLD].adoptBackendNode(event.backendNodeId), false); + const fileChooser = new FileChooser(handle.move(), event); + for (const promise of this.#fileChooserDeferreds) { + promise.resolve(fileChooser); + } + this.#fileChooserDeferreds.clear(); + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources4(env_1); + } + } + _client() { + return this.#primaryTargetClient; + } + isServiceWorkerBypassed() { + return this.#serviceWorkerBypassed; + } + isDragInterceptionEnabled() { + return this.#userDragInterceptionEnabled; + } + isJavaScriptEnabled() { + return this.#emulationManager.javascriptEnabled; + } + async waitForFileChooser(options = {}) { + const needsEnable = this.#fileChooserDeferreds.size === 0; + const { timeout: timeout2 = this._timeoutSettings.timeout() } = options; + const deferred = Deferred.create({ + message: `Waiting for \`FileChooser\` failed: ${timeout2}ms exceeded`, + timeout: timeout2 + }); + if (options.signal) { + options.signal.addEventListener("abort", () => { + deferred.reject(options.signal?.reason); + }, { once: true }); + } + this.#fileChooserDeferreds.add(deferred); + let enablePromise; + if (needsEnable) { + enablePromise = this.#primaryTargetClient.send("Page.setInterceptFileChooserDialog", { + enabled: true + }); + } + try { + const [result] = await Promise.all([ + deferred.valueOrThrow(), + enablePromise + ]); + return result; + } catch (error) { + this.#fileChooserDeferreds.delete(deferred); + throw error; + } + } + async setGeolocation(options) { + return await this.#emulationManager.setGeolocation(options); + } + target() { + return this.#primaryTarget; + } + browser() { + return this.#primaryTarget.browser(); + } + browserContext() { + return this.#primaryTarget.browserContext(); + } + #onTargetCrashed() { + this.emit("error", new Error("Page crashed!")); + } + #onLogEntryAdded(event) { + const { level, text, args, source, url, lineNumber } = event.entry; + if (args) { + args.map((arg) => { + void releaseObject(this.#primaryTargetClient, arg); + }); + } + if (source !== "worker") { + this.emit("console", new ConsoleMessage(convertConsoleMessageLevel(level), text, [], [{ url, lineNumber }])); + } + } + mainFrame() { + return this.#frameManager.mainFrame(); + } + get keyboard() { + return this.#keyboard; + } + get touchscreen() { + return this.#touchscreen; + } + get coverage() { + return this.#coverage; + } + get tracing() { + return this.#tracing; + } + frames() { + return this.#frameManager.frames(); + } + workers() { + return Array.from(this.#workers.values()); + } + async setRequestInterception(value) { + return await this.#frameManager.networkManager.setRequestInterception(value); + } + async setBypassServiceWorker(bypass) { + this.#serviceWorkerBypassed = bypass; + return await this.#primaryTargetClient.send("Network.setBypassServiceWorker", { bypass }); + } + async setDragInterception(enabled) { + this.#userDragInterceptionEnabled = enabled; + return await this.#primaryTargetClient.send("Input.setInterceptDrags", { + enabled + }); + } + async setOfflineMode(enabled) { + return await this.#frameManager.networkManager.setOfflineMode(enabled); + } + async emulateNetworkConditions(networkConditions) { + return await this.#frameManager.networkManager.emulateNetworkConditions(networkConditions); + } + setDefaultNavigationTimeout(timeout2) { + this._timeoutSettings.setDefaultNavigationTimeout(timeout2); + } + setDefaultTimeout(timeout2) { + this._timeoutSettings.setDefaultTimeout(timeout2); + } + getDefaultTimeout() { + return this._timeoutSettings.timeout(); + } + getDefaultNavigationTimeout() { + return this._timeoutSettings.navigationTimeout(); + } + async queryObjects(prototypeHandle) { + assert(!prototypeHandle.disposed, "Prototype JSHandle is disposed!"); + assert(prototypeHandle.id, "Prototype JSHandle must not be referencing primitive value"); + const response = await this.mainFrame().client.send("Runtime.queryObjects", { + prototypeObjectId: prototypeHandle.id + }); + return this.mainFrame().mainRealm().createCdpHandle(response.objects); + } + async cookies(...urls) { + const originalCookies = (await this.#primaryTargetClient.send("Network.getCookies", { + urls: urls.length ? urls : [this.url()] + })).cookies; + const unsupportedCookieAttributes = ["sourcePort"]; + const filterUnsupportedAttributes = (cookie) => { + for (const attr of unsupportedCookieAttributes) { + delete cookie[attr]; + } + return cookie; + }; + return originalCookies.map(filterUnsupportedAttributes).map((cookie) => { + return { + ...cookie, + // TODO: a breaking change is needed in Puppeteer types to support other + // partition keys. + partitionKey: cookie.partitionKey ? cookie.partitionKey.topLevelSite : void 0 + }; + }); + } + async deleteCookie(...cookies) { + const pageURL = this.url(); + for (const cookie of cookies) { + const item = { + ...cookie, + // TODO: a breaking change neeeded to change the partition key + // type in Puppeteer. + partitionKey: cookie.partitionKey ? { topLevelSite: cookie.partitionKey, hasCrossSiteAncestor: false } : void 0 + }; + if (!cookie.url && pageURL.startsWith("http")) { + item.url = pageURL; + } + await this.#primaryTargetClient.send("Network.deleteCookies", item); + if (pageURL.startsWith("http") && !item.partitionKey) { + const url = new URL(pageURL); + await this.#primaryTargetClient.send("Network.deleteCookies", { + ...item, + partitionKey: { + topLevelSite: url.origin.replace(`:${url.port}`, ""), + hasCrossSiteAncestor: false + } + }); + } + } + } + async setCookie(...cookies) { + const pageURL = this.url(); + const startsWithHTTP = pageURL.startsWith("http"); + const items = cookies.map((cookie) => { + const item = Object.assign({}, cookie); + if (!item.url && startsWithHTTP) { + item.url = pageURL; + } + assert(item.url !== "about:blank", `Blank page can not have cookie "${item.name}"`); + assert(!String.prototype.startsWith.call(item.url || "", "data:"), `Data URL page can not have cookie "${item.name}"`); + return item; + }); + await this.deleteCookie(...items); + if (items.length) { + await this.#primaryTargetClient.send("Network.setCookies", { + cookies: items.map((cookieParam) => { + return { + ...cookieParam, + partitionKey: cookieParam.partitionKey ? { + // TODO: a breaking change neeeded to change the partition key + // type in Puppeteer. + topLevelSite: cookieParam.partitionKey, + hasCrossSiteAncestor: false + } : void 0 + }; + }) + }); + } + } + async exposeFunction(name, pptrFunction) { + if (this.#bindings.has(name)) { + throw new Error(`Failed to add page binding with name ${name}: window['${name}'] already exists!`); + } + const source = pageBindingInitString("exposedFun", name); + let binding; + switch (typeof pptrFunction) { + case "function": + binding = new Binding(name, pptrFunction, source); + break; + default: + binding = new Binding(name, pptrFunction.default, source); + break; + } + this.#bindings.set(name, binding); + const [{ identifier }] = await Promise.all([ + this.#frameManager.evaluateOnNewDocument(source), + this.#frameManager.addExposedFunctionBinding(binding) + ]); + this.#exposedFunctions.set(name, identifier); + } + async removeExposedFunction(name) { + const exposedFunctionId = this.#exposedFunctions.get(name); + if (!exposedFunctionId) { + throw new Error(`Function with name "${name}" does not exist`); + } + const binding = this.#bindings.get(name); + this.#exposedFunctions.delete(name); + this.#bindings.delete(name); + await Promise.all([ + this.#frameManager.removeScriptToEvaluateOnNewDocument(exposedFunctionId), + this.#frameManager.removeExposedFunctionBinding(binding) + ]); + } + async authenticate(credentials) { + return await this.#frameManager.networkManager.authenticate(credentials); + } + async setExtraHTTPHeaders(headers) { + return await this.#frameManager.networkManager.setExtraHTTPHeaders(headers); + } + async setUserAgent(userAgent, userAgentMetadata) { + return await this.#frameManager.networkManager.setUserAgent(userAgent, userAgentMetadata); + } + async metrics() { + const response = await this.#primaryTargetClient.send("Performance.getMetrics"); + return this.#buildMetricsObject(response.metrics); + } + #emitMetrics(event) { + this.emit("metrics", { + title: event.title, + metrics: this.#buildMetricsObject(event.metrics) + }); + } + #buildMetricsObject(metrics) { + const result = {}; + for (const metric of metrics || []) { + if (supportedMetrics.has(metric.name)) { + result[metric.name] = metric.value; + } + } + return result; + } + #handleException(exception) { + this.emit("pageerror", createClientError(exception.exceptionDetails)); + } + #onConsoleAPI(world, event) { + const values = event.args.map((arg) => { + return world.createCdpHandle(arg); + }); + this.#addConsoleMessage(convertConsoleMessageLevel(event.type), values, event.stackTrace); + } + async #onBindingCalled(world, event) { + let payload; + try { + payload = JSON.parse(event.payload); + } catch { + return; + } + const { type, name, seq, args, isTrivial } = payload; + if (type !== "exposedFun") { + return; + } + const context = world.context; + if (!context) { + return; + } + const binding = this.#bindings.get(name); + await binding?.run(context, seq, args, isTrivial); + } + #addConsoleMessage(eventType, args, stackTrace) { + if (!this.listenerCount( + "console" + /* PageEvent.Console */ + )) { + args.forEach((arg) => { + return arg.dispose(); + }); + return; + } + const textTokens = []; + for (const arg of args) { + const remoteObject = arg.remoteObject(); + if (remoteObject.objectId) { + textTokens.push(arg.toString()); + } else { + textTokens.push(valueFromRemoteObject(remoteObject)); + } + } + const stackTraceLocations = []; + if (stackTrace) { + for (const callFrame of stackTrace.callFrames) { + stackTraceLocations.push({ + url: callFrame.url, + lineNumber: callFrame.lineNumber, + columnNumber: callFrame.columnNumber + }); + } + } + const message = new ConsoleMessage(convertConsoleMessageLevel(eventType), textTokens.join(" "), args, stackTraceLocations); + this.emit("console", message); + } + #onDialog(event) { + const type = validateDialogType(event.type); + const dialog = new CdpDialog(this.#primaryTargetClient, type, event.message, event.defaultPrompt); + this.emit("dialog", dialog); + } + async reload(options) { + const [result] = await Promise.all([ + this.waitForNavigation({ + ...options, + ignoreSameDocumentNavigation: true + }), + this.#primaryTargetClient.send("Page.reload") + ]); + return result; + } + async createCDPSession() { + return await this.target().createCDPSession(); + } + async goBack(options = {}) { + return await this.#go(-1, options); + } + async goForward(options = {}) { + return await this.#go(1, options); + } + async #go(delta, options) { + const history = await this.#primaryTargetClient.send("Page.getNavigationHistory"); + const entry = history.entries[history.currentIndex + delta]; + if (!entry) { + return null; + } + const result = await Promise.all([ + this.waitForNavigation(options), + this.#primaryTargetClient.send("Page.navigateToHistoryEntry", { + entryId: entry.id + }) + ]); + return result[0]; + } + async bringToFront() { + await this.#primaryTargetClient.send("Page.bringToFront"); + } + async setJavaScriptEnabled(enabled) { + return await this.#emulationManager.setJavaScriptEnabled(enabled); + } + async setBypassCSP(enabled) { + await this.#primaryTargetClient.send("Page.setBypassCSP", { enabled }); + } + async emulateMediaType(type) { + return await this.#emulationManager.emulateMediaType(type); + } + async emulateCPUThrottling(factor) { + return await this.#emulationManager.emulateCPUThrottling(factor); + } + async emulateMediaFeatures(features) { + return await this.#emulationManager.emulateMediaFeatures(features); + } + async emulateTimezone(timezoneId) { + return await this.#emulationManager.emulateTimezone(timezoneId); + } + async emulateIdleState(overrides) { + return await this.#emulationManager.emulateIdleState(overrides); + } + async emulateVisionDeficiency(type) { + return await this.#emulationManager.emulateVisionDeficiency(type); + } + async setViewport(viewport) { + const needsReload = await this.#emulationManager.emulateViewport(viewport); + this.#viewport = viewport; + if (needsReload) { + await this.reload(); + } + } + viewport() { + return this.#viewport; + } + async evaluateOnNewDocument(pageFunction, ...args) { + const source = evaluationString(pageFunction, ...args); + return await this.#frameManager.evaluateOnNewDocument(source); + } + async removeScriptToEvaluateOnNewDocument(identifier) { + return await this.#frameManager.removeScriptToEvaluateOnNewDocument(identifier); + } + async setCacheEnabled(enabled = true) { + await this.#frameManager.networkManager.setCacheEnabled(enabled); + } + async _screenshot(options) { + const env_2 = { stack: [], error: void 0, hasError: false }; + try { + const { fromSurface, omitBackground, optimizeForSpeed, quality, clip: userClip, type, captureBeyondViewport } = options; + const isFirefox = this.target()._targetManager() instanceof FirefoxTargetManager; + const stack = __addDisposableResource4(env_2, new AsyncDisposableStack(), true); + if (!isFirefox && omitBackground && (type === "png" || type === "webp")) { + await this.#emulationManager.setTransparentBackgroundColor(); + stack.defer(async () => { + await this.#emulationManager.resetDefaultBackgroundColor().catch(debugError); + }); + } + let clip = userClip; + if (clip && !captureBeyondViewport) { + const viewport = await this.mainFrame().isolatedRealm().evaluate(() => { + const { height, pageLeft: x, pageTop: y, width } = window.visualViewport; + return { x, y, height, width }; + }); + clip = getIntersectionRect(clip, viewport); + } + const { data } = await this.#primaryTargetClient.send("Page.captureScreenshot", { + format: type, + ...optimizeForSpeed ? { optimizeForSpeed } : {}, + ...quality !== void 0 ? { quality: Math.round(quality) } : {}, + ...clip ? { clip: { ...clip, scale: clip.scale ?? 1 } } : {}, + ...!fromSurface ? { fromSurface } : {}, + captureBeyondViewport + }); + return data; + } catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } finally { + const result_1 = __disposeResources4(env_2); + if (result_1) + await result_1; + } + } + async createPDFStream(options = {}) { + const { timeout: ms = this._timeoutSettings.timeout() } = options; + const { landscape, displayHeaderFooter, headerTemplate, footerTemplate, printBackground, scale, width: paperWidth, height: paperHeight, margin, pageRanges, preferCSSPageSize, omitBackground, tagged: generateTaggedPDF, outline: generateDocumentOutline, waitForFonts } = parsePDFOptions(options); + if (omitBackground) { + await this.#emulationManager.setTransparentBackgroundColor(); + } + if (waitForFonts) { + await firstValueFrom(from(this.mainFrame().isolatedRealm().evaluate(() => { + return document.fonts.ready; + })).pipe(raceWith(timeout(ms)))); + } + const printCommandPromise = this.#primaryTargetClient.send("Page.printToPDF", { + transferMode: "ReturnAsStream", + landscape, + displayHeaderFooter, + headerTemplate, + footerTemplate, + printBackground, + scale, + paperWidth, + paperHeight, + marginTop: margin.top, + marginBottom: margin.bottom, + marginLeft: margin.left, + marginRight: margin.right, + pageRanges, + preferCSSPageSize, + generateTaggedPDF, + generateDocumentOutline + }); + const result = await firstValueFrom(from(printCommandPromise).pipe(raceWith(timeout(ms)))); + if (omitBackground) { + await this.#emulationManager.resetDefaultBackgroundColor(); + } + assert(result.stream, "`stream` is missing from `Page.printToPDF"); + return await getReadableFromProtocolStream(this.#primaryTargetClient, result.stream); + } + async pdf(options = {}) { + const { path: path10 = void 0 } = options; + const readable = await this.createPDFStream(options); + const typedArray = await getReadableAsTypedArray(readable, path10); + assert(typedArray, "Could not create typed array"); + return typedArray; + } + async close(options = { runBeforeUnload: void 0 }) { + const env_3 = { stack: [], error: void 0, hasError: false }; + try { + const _guard = __addDisposableResource4(env_3, await this.browserContext().waitForScreenshotOperations(), false); + const connection = this.#primaryTargetClient.connection(); + assert(connection, "Protocol error: Connection closed. Most likely the page has been closed."); + const runBeforeUnload = !!options.runBeforeUnload; + if (runBeforeUnload) { + await this.#primaryTargetClient.send("Page.close"); + } else { + await connection.send("Target.closeTarget", { + targetId: this.#primaryTarget._targetId + }); + await this.#tabTarget._isClosedDeferred.valueOrThrow(); + } + } catch (e_3) { + env_3.error = e_3; + env_3.hasError = true; + } finally { + __disposeResources4(env_3); + } + } + isClosed() { + return this.#closed; + } + get mouse() { + return this.#mouse; + } + /** + * This method is typically coupled with an action that triggers a device + * request from an api such as WebBluetooth. + * + * :::caution + * + * This must be called before the device request is made. It will not return a + * currently active device prompt. + * + * ::: + * + * @example + * + * ```ts + * const [devicePrompt] = Promise.all([ + * page.waitForDevicePrompt(), + * page.click('#connect-bluetooth'), + * ]); + * await devicePrompt.select( + * await devicePrompt.waitForDevice(({name}) => name.includes('My Device')), + * ); + * ``` + */ + async waitForDevicePrompt(options = {}) { + return await this.mainFrame().waitForDevicePrompt(options); + } +}; +var supportedMetrics = /* @__PURE__ */ new Set([ + "Timestamp", + "Documents", + "Frames", + "JSEventListeners", + "Nodes", + "LayoutCount", + "RecalcStyleCount", + "LayoutDuration", + "RecalcStyleDuration", + "ScriptDuration", + "TaskDuration", + "JSHeapUsedSize", + "JSHeapTotalSize" +]); +function getIntersectionRect(clip, viewport) { + const x = Math.max(clip.x, viewport.x); + const y = Math.max(clip.y, viewport.y); + return { + x, + y, + width: Math.max(Math.min(clip.x + clip.width, viewport.x + viewport.width) - x, 0), + height: Math.max(Math.min(clip.y + clip.height, viewport.y + viewport.height) - y, 0) + }; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Target.js +var InitializationStatus; +(function(InitializationStatus2) { + InitializationStatus2["SUCCESS"] = "success"; + InitializationStatus2["ABORTED"] = "aborted"; +})(InitializationStatus || (InitializationStatus = {})); +var CdpTarget = class extends Target { + #browserContext; + #session; + #targetInfo; + #targetManager; + #sessionFactory; + #childTargets = /* @__PURE__ */ new Set(); + _initializedDeferred = Deferred.create(); + _isClosedDeferred = Deferred.create(); + _targetId; + /** + * To initialize the target for use, call initialize. + * + * @internal + */ + constructor(targetInfo, session, browserContext, targetManager, sessionFactory) { + super(); + this.#session = session; + this.#targetManager = targetManager; + this.#targetInfo = targetInfo; + this.#browserContext = browserContext; + this._targetId = targetInfo.targetId; + this.#sessionFactory = sessionFactory; + if (this.#session && this.#session instanceof CdpCDPSession) { + this.#session._setTarget(this); + } + } + async asPage() { + const session = this._session(); + if (!session) { + return await this.createCDPSession().then((client) => { + return CdpPage._create(client, this, null); + }); + } + return await CdpPage._create(session, this, null); + } + _subtype() { + return this.#targetInfo.subtype; + } + _session() { + return this.#session; + } + _addChildTarget(target) { + this.#childTargets.add(target); + } + _removeChildTarget(target) { + this.#childTargets.delete(target); + } + _childTargets() { + return this.#childTargets; + } + _sessionFactory() { + if (!this.#sessionFactory) { + throw new Error("sessionFactory is not initialized"); + } + return this.#sessionFactory; + } + createCDPSession() { + if (!this.#sessionFactory) { + throw new Error("sessionFactory is not initialized"); + } + return this.#sessionFactory(false).then((session) => { + session._setTarget(this); + return session; + }); + } + url() { + return this.#targetInfo.url; + } + type() { + const type = this.#targetInfo.type; + switch (type) { + case "page": + return TargetType.PAGE; + case "background_page": + return TargetType.BACKGROUND_PAGE; + case "service_worker": + return TargetType.SERVICE_WORKER; + case "shared_worker": + return TargetType.SHARED_WORKER; + case "browser": + return TargetType.BROWSER; + case "webview": + return TargetType.WEBVIEW; + case "tab": + return TargetType.TAB; + default: + return TargetType.OTHER; + } + } + _targetManager() { + if (!this.#targetManager) { + throw new Error("targetManager is not initialized"); + } + return this.#targetManager; + } + _getTargetInfo() { + return this.#targetInfo; + } + browser() { + if (!this.#browserContext) { + throw new Error("browserContext is not initialized"); + } + return this.#browserContext.browser(); + } + browserContext() { + if (!this.#browserContext) { + throw new Error("browserContext is not initialized"); + } + return this.#browserContext; + } + opener() { + const { openerId } = this.#targetInfo; + if (!openerId) { + return; + } + return this.browser().targets().find((target) => { + return target._targetId === openerId; + }); + } + _targetInfoChanged(targetInfo) { + this.#targetInfo = targetInfo; + this._checkIfInitialized(); + } + _initialize() { + this._initializedDeferred.resolve(InitializationStatus.SUCCESS); + } + _isTargetExposed() { + return this.type() !== TargetType.TAB && !this._subtype(); + } + _checkIfInitialized() { + if (!this._initializedDeferred.resolved()) { + this._initializedDeferred.resolve(InitializationStatus.SUCCESS); + } + } +}; +var PageTarget = class extends CdpTarget { + #defaultViewport; + pagePromise; + constructor(targetInfo, session, browserContext, targetManager, sessionFactory, defaultViewport) { + super(targetInfo, session, browserContext, targetManager, sessionFactory); + this.#defaultViewport = defaultViewport ?? void 0; + } + _initialize() { + this._initializedDeferred.valueOrThrow().then(async (result) => { + if (result === InitializationStatus.ABORTED) { + return; + } + const opener = this.opener(); + if (!(opener instanceof PageTarget)) { + return; + } + if (!opener || !opener.pagePromise || this.type() !== "page") { + return true; + } + const openerPage = await opener.pagePromise; + if (!openerPage.listenerCount( + "popup" + /* PageEvent.Popup */ + )) { + return true; + } + const popupPage = await this.page(); + openerPage.emit("popup", popupPage); + return true; + }).catch(debugError); + this._checkIfInitialized(); + } + async page() { + if (!this.pagePromise) { + const session = this._session(); + this.pagePromise = (session ? Promise.resolve(session) : this._sessionFactory()( + /* isAutoAttachEmulated=*/ + false + )).then((client) => { + return CdpPage._create(client, this, this.#defaultViewport ?? null); + }); + } + return await this.pagePromise ?? null; + } + _checkIfInitialized() { + if (this._initializedDeferred.resolved()) { + return; + } + if (this._getTargetInfo().url !== "") { + this._initializedDeferred.resolve(InitializationStatus.SUCCESS); + } + } +}; +var DevToolsTarget = class extends PageTarget { +}; +var WorkerTarget = class extends CdpTarget { + #workerPromise; + async worker() { + if (!this.#workerPromise) { + const session = this._session(); + this.#workerPromise = (session ? Promise.resolve(session) : this._sessionFactory()( + /* isAutoAttachEmulated=*/ + false + )).then((client) => { + return new CdpWebWorker( + client, + this._getTargetInfo().url, + this._targetId, + this.type(), + () => { + }, + () => { + } + /* exceptionThrown */ + ); + }); + } + return await this.#workerPromise; + } +}; +var OtherTarget = class extends CdpTarget { +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/ChromeTargetManager.js +function isPageTargetBecomingPrimary(target, newTargetInfo) { + return Boolean(target._subtype()) && !newTargetInfo.subtype; +} +var ChromeTargetManager = class extends EventEmitter { + #connection; + /** + * Keeps track of the following events: 'Target.targetCreated', + * 'Target.targetDestroyed', 'Target.targetInfoChanged'. + * + * A target becomes discovered when 'Target.targetCreated' is received. + * A target is removed from this map once 'Target.targetDestroyed' is + * received. + * + * `targetFilterCallback` has no effect on this map. + */ + #discoveredTargetsByTargetId = /* @__PURE__ */ new Map(); + /** + * A target is added to this map once ChromeTargetManager has created + * a Target and attached at least once to it. + */ + #attachedTargetsByTargetId = /* @__PURE__ */ new Map(); + /** + * Tracks which sessions attach to which target. + */ + #attachedTargetsBySessionId = /* @__PURE__ */ new Map(); + /** + * If a target was filtered out by `targetFilterCallback`, we still receive + * events about it from CDP, but we don't forward them to the rest of Puppeteer. + */ + #ignoredTargets = /* @__PURE__ */ new Set(); + #targetFilterCallback; + #targetFactory; + #attachedToTargetListenersBySession = /* @__PURE__ */ new WeakMap(); + #detachedFromTargetListenersBySession = /* @__PURE__ */ new WeakMap(); + #initializeDeferred = Deferred.create(); + #targetsIdsForInit = /* @__PURE__ */ new Set(); + #waitForInitiallyDiscoveredTargets = true; + #discoveryFilter = [{}]; + constructor(connection, targetFactory, targetFilterCallback, waitForInitiallyDiscoveredTargets = true) { + super(); + this.#connection = connection; + this.#targetFilterCallback = targetFilterCallback; + this.#targetFactory = targetFactory; + this.#waitForInitiallyDiscoveredTargets = waitForInitiallyDiscoveredTargets; + this.#connection.on("Target.targetCreated", this.#onTargetCreated); + this.#connection.on("Target.targetDestroyed", this.#onTargetDestroyed); + this.#connection.on("Target.targetInfoChanged", this.#onTargetInfoChanged); + this.#connection.on(CDPSessionEvent.SessionDetached, this.#onSessionDetached); + this.#setupAttachmentListeners(this.#connection); + } + #storeExistingTargetsForInit = () => { + if (!this.#waitForInitiallyDiscoveredTargets) { + return; + } + for (const [targetId, targetInfo] of this.#discoveredTargetsByTargetId.entries()) { + const targetForFilter = new CdpTarget(targetInfo, void 0, void 0, this, void 0); + const isPageOrFrame = targetInfo.type === "page" || targetInfo.type === "iframe"; + const isExtension = targetInfo.url.startsWith("chrome-extension://"); + if ((!this.#targetFilterCallback || this.#targetFilterCallback(targetForFilter)) && isPageOrFrame && !isExtension) { + this.#targetsIdsForInit.add(targetId); + } + } + }; + async initialize() { + await this.#connection.send("Target.setDiscoverTargets", { + discover: true, + filter: this.#discoveryFilter + }); + this.#storeExistingTargetsForInit(); + await this.#connection.send("Target.setAutoAttach", { + waitForDebuggerOnStart: true, + flatten: true, + autoAttach: true, + filter: [ + { + type: "page", + exclude: true + }, + ...this.#discoveryFilter + ] + }); + this.#finishInitializationIfReady(); + await this.#initializeDeferred.valueOrThrow(); + } + getChildTargets(target) { + return target._childTargets(); + } + dispose() { + this.#connection.off("Target.targetCreated", this.#onTargetCreated); + this.#connection.off("Target.targetDestroyed", this.#onTargetDestroyed); + this.#connection.off("Target.targetInfoChanged", this.#onTargetInfoChanged); + this.#connection.off(CDPSessionEvent.SessionDetached, this.#onSessionDetached); + this.#removeAttachmentListeners(this.#connection); + } + getAvailableTargets() { + return this.#attachedTargetsByTargetId; + } + #setupAttachmentListeners(session) { + const listener = (event) => { + void this.#onAttachedToTarget(session, event); + }; + assert(!this.#attachedToTargetListenersBySession.has(session)); + this.#attachedToTargetListenersBySession.set(session, listener); + session.on("Target.attachedToTarget", listener); + const detachedListener = (event) => { + return this.#onDetachedFromTarget(session, event); + }; + assert(!this.#detachedFromTargetListenersBySession.has(session)); + this.#detachedFromTargetListenersBySession.set(session, detachedListener); + session.on("Target.detachedFromTarget", detachedListener); + } + #removeAttachmentListeners(session) { + const listener = this.#attachedToTargetListenersBySession.get(session); + if (listener) { + session.off("Target.attachedToTarget", listener); + this.#attachedToTargetListenersBySession.delete(session); + } + if (this.#detachedFromTargetListenersBySession.has(session)) { + session.off("Target.detachedFromTarget", this.#detachedFromTargetListenersBySession.get(session)); + this.#detachedFromTargetListenersBySession.delete(session); + } + } + #onSessionDetached = (session) => { + this.#removeAttachmentListeners(session); + }; + #onTargetCreated = async (event) => { + this.#discoveredTargetsByTargetId.set(event.targetInfo.targetId, event.targetInfo); + this.emit("targetDiscovered", event.targetInfo); + if (event.targetInfo.type === "browser" && event.targetInfo.attached) { + if (this.#attachedTargetsByTargetId.has(event.targetInfo.targetId)) { + return; + } + const target = this.#targetFactory(event.targetInfo, void 0); + target._initialize(); + this.#attachedTargetsByTargetId.set(event.targetInfo.targetId, target); + } + }; + #onTargetDestroyed = (event) => { + const targetInfo = this.#discoveredTargetsByTargetId.get(event.targetId); + this.#discoveredTargetsByTargetId.delete(event.targetId); + this.#finishInitializationIfReady(event.targetId); + if (targetInfo?.type === "service_worker" && this.#attachedTargetsByTargetId.has(event.targetId)) { + const target = this.#attachedTargetsByTargetId.get(event.targetId); + if (target) { + this.emit("targetGone", target); + this.#attachedTargetsByTargetId.delete(event.targetId); + } + } + }; + #onTargetInfoChanged = (event) => { + this.#discoveredTargetsByTargetId.set(event.targetInfo.targetId, event.targetInfo); + if (this.#ignoredTargets.has(event.targetInfo.targetId) || !this.#attachedTargetsByTargetId.has(event.targetInfo.targetId) || !event.targetInfo.attached) { + return; + } + const target = this.#attachedTargetsByTargetId.get(event.targetInfo.targetId); + if (!target) { + return; + } + const previousURL = target.url(); + const wasInitialized = target._initializedDeferred.value() === InitializationStatus.SUCCESS; + if (isPageTargetBecomingPrimary(target, event.targetInfo)) { + const session = target?._session(); + assert(session, "Target that is being activated is missing a CDPSession."); + session.parentSession()?.emit(CDPSessionEvent.Swapped, session); + } + target._targetInfoChanged(event.targetInfo); + if (wasInitialized && previousURL !== target.url()) { + this.emit("targetChanged", { + target, + wasInitialized, + previousURL + }); + } + }; + #onAttachedToTarget = async (parentSession, event) => { + const targetInfo = event.targetInfo; + const session = this.#connection.session(event.sessionId); + if (!session) { + throw new Error(`Session ${event.sessionId} was not created.`); + } + const silentDetach = async () => { + await session.send("Runtime.runIfWaitingForDebugger").catch(debugError); + await parentSession.send("Target.detachFromTarget", { + sessionId: session.id() + }).catch(debugError); + }; + if (!this.#connection.isAutoAttached(targetInfo.targetId)) { + return; + } + if (targetInfo.type === "service_worker") { + this.#finishInitializationIfReady(targetInfo.targetId); + await silentDetach(); + if (this.#attachedTargetsByTargetId.has(targetInfo.targetId)) { + return; + } + const target2 = this.#targetFactory(targetInfo); + target2._initialize(); + this.#attachedTargetsByTargetId.set(targetInfo.targetId, target2); + this.emit("targetAvailable", target2); + return; + } + const isExistingTarget = this.#attachedTargetsByTargetId.has(targetInfo.targetId); + const target = isExistingTarget ? this.#attachedTargetsByTargetId.get(targetInfo.targetId) : this.#targetFactory(targetInfo, session, parentSession instanceof CDPSession ? parentSession : void 0); + if (this.#targetFilterCallback && !this.#targetFilterCallback(target)) { + this.#ignoredTargets.add(targetInfo.targetId); + this.#finishInitializationIfReady(targetInfo.targetId); + await silentDetach(); + return; + } + this.#setupAttachmentListeners(session); + if (isExistingTarget) { + session._setTarget(target); + this.#attachedTargetsBySessionId.set(session.id(), this.#attachedTargetsByTargetId.get(targetInfo.targetId)); + } else { + target._initialize(); + this.#attachedTargetsByTargetId.set(targetInfo.targetId, target); + this.#attachedTargetsBySessionId.set(session.id(), target); + } + const parentTarget = parentSession instanceof CDPSession ? parentSession._target() : null; + parentTarget?._addChildTarget(target); + parentSession.emit(CDPSessionEvent.Ready, session); + this.#targetsIdsForInit.delete(target._targetId); + if (!isExistingTarget) { + this.emit("targetAvailable", target); + } + this.#finishInitializationIfReady(); + await Promise.all([ + session.send("Target.setAutoAttach", { + waitForDebuggerOnStart: true, + flatten: true, + autoAttach: true, + filter: this.#discoveryFilter + }), + session.send("Runtime.runIfWaitingForDebugger") + ]).catch(debugError); + }; + #finishInitializationIfReady(targetId) { + if (targetId !== void 0) { + this.#targetsIdsForInit.delete(targetId); + } + if (this.#targetsIdsForInit.size === 0) { + this.#initializeDeferred.resolve(); + } + } + #onDetachedFromTarget = (parentSession, event) => { + const target = this.#attachedTargetsBySessionId.get(event.sessionId); + this.#attachedTargetsBySessionId.delete(event.sessionId); + if (!target) { + return; + } + if (parentSession instanceof CDPSession) { + parentSession._target()._removeChildTarget(target); + } + this.#attachedTargetsByTargetId.delete(target._targetId); + this.emit("targetGone", target); + }; +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Browser.js +var CdpBrowser = class extends Browser { + protocol = "cdp"; + static async _create(product, connection, contextIds, acceptInsecureCerts, defaultViewport, downloadBehavior, process2, closeCallback, targetFilterCallback, isPageTargetCallback, waitForInitiallyDiscoveredTargets = true) { + const browser = new CdpBrowser(product, connection, contextIds, defaultViewport, process2, closeCallback, targetFilterCallback, isPageTargetCallback, waitForInitiallyDiscoveredTargets); + if (acceptInsecureCerts) { + await connection.send("Security.setIgnoreCertificateErrors", { + ignore: true + }); + } + await browser._attach(downloadBehavior); + return browser; + } + #defaultViewport; + #process; + #connection; + #closeCallback; + #targetFilterCallback; + #isPageTargetCallback; + #defaultContext; + #contexts = /* @__PURE__ */ new Map(); + #targetManager; + constructor(product, connection, contextIds, defaultViewport, process2, closeCallback, targetFilterCallback, isPageTargetCallback, waitForInitiallyDiscoveredTargets = true) { + super(); + product = product || "chrome"; + this.#defaultViewport = defaultViewport; + this.#process = process2; + this.#connection = connection; + this.#closeCallback = closeCallback || (() => { + }); + this.#targetFilterCallback = targetFilterCallback || (() => { + return true; + }); + this.#setIsPageTargetCallback(isPageTargetCallback); + if (product === "firefox") { + this.#targetManager = new FirefoxTargetManager(connection, this.#createTarget, this.#targetFilterCallback); + } else { + this.#targetManager = new ChromeTargetManager(connection, this.#createTarget, this.#targetFilterCallback, waitForInitiallyDiscoveredTargets); + } + this.#defaultContext = new CdpBrowserContext(this.#connection, this); + for (const contextId of contextIds) { + this.#contexts.set(contextId, new CdpBrowserContext(this.#connection, this, contextId)); + } + } + #emitDisconnected = () => { + this.emit("disconnected", void 0); + }; + async _attach(downloadBehavior) { + this.#connection.on(CDPSessionEvent.Disconnected, this.#emitDisconnected); + if (downloadBehavior) { + await this.#defaultContext.setDownloadBehavior(downloadBehavior); + } + this.#targetManager.on("targetAvailable", this.#onAttachedToTarget); + this.#targetManager.on("targetGone", this.#onDetachedFromTarget); + this.#targetManager.on("targetChanged", this.#onTargetChanged); + this.#targetManager.on("targetDiscovered", this.#onTargetDiscovered); + await this.#targetManager.initialize(); + } + _detach() { + this.#connection.off(CDPSessionEvent.Disconnected, this.#emitDisconnected); + this.#targetManager.off("targetAvailable", this.#onAttachedToTarget); + this.#targetManager.off("targetGone", this.#onDetachedFromTarget); + this.#targetManager.off("targetChanged", this.#onTargetChanged); + this.#targetManager.off("targetDiscovered", this.#onTargetDiscovered); + } + process() { + return this.#process ?? null; + } + _targetManager() { + return this.#targetManager; + } + #setIsPageTargetCallback(isPageTargetCallback) { + this.#isPageTargetCallback = isPageTargetCallback || ((target) => { + return target.type() === "page" || target.type() === "background_page" || target.type() === "webview"; + }); + } + _getIsPageTargetCallback() { + return this.#isPageTargetCallback; + } + async createBrowserContext(options = {}) { + const { proxyServer, proxyBypassList, downloadBehavior } = options; + const { browserContextId } = await this.#connection.send("Target.createBrowserContext", { + proxyServer, + proxyBypassList: proxyBypassList && proxyBypassList.join(",") + }); + const context = new CdpBrowserContext(this.#connection, this, browserContextId); + if (downloadBehavior) { + await context.setDownloadBehavior(downloadBehavior); + } + this.#contexts.set(browserContextId, context); + return context; + } + browserContexts() { + return [this.#defaultContext, ...Array.from(this.#contexts.values())]; + } + defaultBrowserContext() { + return this.#defaultContext; + } + async _disposeContext(contextId) { + if (!contextId) { + return; + } + await this.#connection.send("Target.disposeBrowserContext", { + browserContextId: contextId + }); + this.#contexts.delete(contextId); + } + #createTarget = (targetInfo, session) => { + const { browserContextId } = targetInfo; + const context = browserContextId && this.#contexts.has(browserContextId) ? this.#contexts.get(browserContextId) : this.#defaultContext; + if (!context) { + throw new Error("Missing browser context"); + } + const createSession = (isAutoAttachEmulated) => { + return this.#connection._createSession(targetInfo, isAutoAttachEmulated); + }; + const otherTarget = new OtherTarget(targetInfo, session, context, this.#targetManager, createSession); + if (targetInfo.url?.startsWith("devtools://")) { + return new DevToolsTarget(targetInfo, session, context, this.#targetManager, createSession, this.#defaultViewport ?? null); + } + if (this.#isPageTargetCallback(otherTarget)) { + return new PageTarget(targetInfo, session, context, this.#targetManager, createSession, this.#defaultViewport ?? null); + } + if (targetInfo.type === "service_worker" || targetInfo.type === "shared_worker") { + return new WorkerTarget(targetInfo, session, context, this.#targetManager, createSession); + } + return otherTarget; + }; + #onAttachedToTarget = async (target) => { + if (target._isTargetExposed() && await target._initializedDeferred.valueOrThrow() === InitializationStatus.SUCCESS) { + this.emit("targetcreated", target); + target.browserContext().emit("targetcreated", target); + } + }; + #onDetachedFromTarget = async (target) => { + target._initializedDeferred.resolve(InitializationStatus.ABORTED); + target._isClosedDeferred.resolve(); + if (target._isTargetExposed() && await target._initializedDeferred.valueOrThrow() === InitializationStatus.SUCCESS) { + this.emit("targetdestroyed", target); + target.browserContext().emit("targetdestroyed", target); + } + }; + #onTargetChanged = ({ target }) => { + this.emit("targetchanged", target); + target.browserContext().emit("targetchanged", target); + }; + #onTargetDiscovered = (targetInfo) => { + this.emit("targetdiscovered", targetInfo); + }; + wsEndpoint() { + return this.#connection.url(); + } + async newPage() { + return await this.#defaultContext.newPage(); + } + async _createPageInContext(contextId) { + const { targetId } = await this.#connection.send("Target.createTarget", { + url: "about:blank", + browserContextId: contextId || void 0 + }); + const target = await this.waitForTarget((t) => { + return t._targetId === targetId; + }); + if (!target) { + throw new Error(`Missing target for page (id = ${targetId})`); + } + const initialized = await target._initializedDeferred.valueOrThrow() === InitializationStatus.SUCCESS; + if (!initialized) { + throw new Error(`Failed to create target for page (id = ${targetId})`); + } + const page = await target.page(); + if (!page) { + throw new Error(`Failed to create a page for context (id = ${contextId})`); + } + return page; + } + targets() { + return Array.from(this.#targetManager.getAvailableTargets().values()).filter((target) => { + return target._isTargetExposed() && target._initializedDeferred.value() === InitializationStatus.SUCCESS; + }); + } + target() { + const browserTarget = this.targets().find((target) => { + return target.type() === "browser"; + }); + if (!browserTarget) { + throw new Error("Browser target is not found"); + } + return browserTarget; + } + async version() { + const version2 = await this.#getVersion(); + return version2.product; + } + async userAgent() { + const version2 = await this.#getVersion(); + return version2.userAgent; + } + async close() { + await this.#closeCallback.call(null); + await this.disconnect(); + } + disconnect() { + this.#targetManager.dispose(); + this.#connection.dispose(); + this._detach(); + return Promise.resolve(); + } + get connected() { + return !this.#connection._closed; + } + #getVersion() { + return this.#connection.send("Browser.getVersion"); + } + get debugInfo() { + return { + pendingProtocolErrors: this.#connection.getPendingProtocolErrors() + }; + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/BrowserConnector.js +init_cjs_shim(); +async function _connectToCdpBrowser(connectionTransport, url, options) { + const { acceptInsecureCerts = false, defaultViewport = DEFAULT_VIEWPORT, downloadBehavior, targetFilter, _isPageTarget: isPageTarget, slowMo = 0, protocolTimeout } = options; + const connection = new Connection(url, connectionTransport, slowMo, protocolTimeout); + const version2 = await connection.send("Browser.getVersion"); + const product = version2.product.toLowerCase().includes("firefox") ? "firefox" : "chrome"; + const { browserContextIds } = await connection.send("Target.getBrowserContexts"); + const browser = await CdpBrowser._create(product || "chrome", connection, browserContextIds, acceptInsecureCerts, defaultViewport, downloadBehavior, void 0, () => { + return connection.send("Browser.close").catch(debugError); + }, targetFilter, isPageTarget); + return browser; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/ExtensionTransport.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/PredefinedNetworkConditions.js +init_cjs_shim(); +var PredefinedNetworkConditions = Object.freeze({ + // Generally aligned with DevTools + // https://source.chromium.org/chromium/chromium/src/+/main:third_party/devtools-frontend/src/front_end/core/sdk/NetworkManager.ts;l=398;drc=225e1240f522ca684473f541ae6dae6cd766dd33. + "Slow 3G": { + // ~500Kbps down + download: 500 * 1e3 / 8 * 0.8, + // ~500Kbps up + upload: 500 * 1e3 / 8 * 0.8, + // 400ms RTT + latency: 400 * 5 + }, + "Fast 3G": { + // ~1.6 Mbps down + download: 1.6 * 1e3 * 1e3 / 8 * 0.9, + // ~0.75 Mbps up + upload: 750 * 1e3 / 8 * 0.9, + // 150ms RTT + latency: 150 * 3.75 + }, + // alias to Fast 3G to align with Lighthouse (crbug.com/342406608) + // and DevTools (crbug.com/342406608), + "Slow 4G": { + // ~1.6 Mbps down + download: 1.6 * 1e3 * 1e3 / 8 * 0.9, + // ~0.75 Mbps up + upload: 750 * 1e3 / 8 * 0.9, + // 150ms RTT + latency: 150 * 3.75 + }, + "Fast 4G": { + // 9 Mbps down + download: 9 * 1e3 * 1e3 / 8 * 0.9, + // 1.5 Mbps up + upload: 1.5 * 1e3 * 1e3 / 8 * 0.9, + // 60ms RTT + latency: 60 * 2.75 + } +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/TargetManager.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/common.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/Device.js +init_cjs_shim(); +var knownDevices = [ + { + name: "Blackberry PlayBook", + userAgent: "Mozilla/5.0 (PlayBook; U; RIM Tablet OS 2.1.0; en-US) AppleWebKit/536.2+ (KHTML like Gecko) Version/7.2.1.0 Safari/536.2+", + viewport: { + width: 600, + height: 1024, + deviceScaleFactor: 1, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Blackberry PlayBook landscape", + userAgent: "Mozilla/5.0 (PlayBook; U; RIM Tablet OS 2.1.0; en-US) AppleWebKit/536.2+ (KHTML like Gecko) Version/7.2.1.0 Safari/536.2+", + viewport: { + width: 1024, + height: 600, + deviceScaleFactor: 1, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "BlackBerry Z30", + userAgent: "Mozilla/5.0 (BB10; Touch) AppleWebKit/537.10+ (KHTML, like Gecko) Version/10.0.9.2372 Mobile Safari/537.10+", + viewport: { + width: 360, + height: 640, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "BlackBerry Z30 landscape", + userAgent: "Mozilla/5.0 (BB10; Touch) AppleWebKit/537.10+ (KHTML, like Gecko) Version/10.0.9.2372 Mobile Safari/537.10+", + viewport: { + width: 640, + height: 360, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Galaxy Note 3", + userAgent: "Mozilla/5.0 (Linux; U; Android 4.3; en-us; SM-N900T Build/JSS15J) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30", + viewport: { + width: 360, + height: 640, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Galaxy Note 3 landscape", + userAgent: "Mozilla/5.0 (Linux; U; Android 4.3; en-us; SM-N900T Build/JSS15J) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30", + viewport: { + width: 640, + height: 360, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Galaxy Note II", + userAgent: "Mozilla/5.0 (Linux; U; Android 4.1; en-us; GT-N7100 Build/JRO03C) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30", + viewport: { + width: 360, + height: 640, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Galaxy Note II landscape", + userAgent: "Mozilla/5.0 (Linux; U; Android 4.1; en-us; GT-N7100 Build/JRO03C) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30", + viewport: { + width: 640, + height: 360, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Galaxy S III", + userAgent: "Mozilla/5.0 (Linux; U; Android 4.0; en-us; GT-I9300 Build/IMM76D) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30", + viewport: { + width: 360, + height: 640, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Galaxy S III landscape", + userAgent: "Mozilla/5.0 (Linux; U; Android 4.0; en-us; GT-I9300 Build/IMM76D) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30", + viewport: { + width: 640, + height: 360, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Galaxy S5", + userAgent: "Mozilla/5.0 (Linux; Android 5.0; SM-G900P Build/LRX21T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 360, + height: 640, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Galaxy S5 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 5.0; SM-G900P Build/LRX21T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 640, + height: 360, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Galaxy S8", + userAgent: "Mozilla/5.0 (Linux; Android 7.0; SM-G950U Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.84 Mobile Safari/537.36", + viewport: { + width: 360, + height: 740, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Galaxy S8 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 7.0; SM-G950U Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.84 Mobile Safari/537.36", + viewport: { + width: 740, + height: 360, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Galaxy S9+", + userAgent: "Mozilla/5.0 (Linux; Android 8.0.0; SM-G965U Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.111 Mobile Safari/537.36", + viewport: { + width: 320, + height: 658, + deviceScaleFactor: 4.5, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Galaxy S9+ landscape", + userAgent: "Mozilla/5.0 (Linux; Android 8.0.0; SM-G965U Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.111 Mobile Safari/537.36", + viewport: { + width: 658, + height: 320, + deviceScaleFactor: 4.5, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Galaxy Tab S4", + userAgent: "Mozilla/5.0 (Linux; Android 8.1.0; SM-T837A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.80 Safari/537.36", + viewport: { + width: 712, + height: 1138, + deviceScaleFactor: 2.25, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Galaxy Tab S4 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 8.1.0; SM-T837A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.80 Safari/537.36", + viewport: { + width: 1138, + height: 712, + deviceScaleFactor: 2.25, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPad", + userAgent: "Mozilla/5.0 (iPad; CPU OS 11_0 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) Version/11.0 Mobile/15A5341f Safari/604.1", + viewport: { + width: 768, + height: 1024, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPad landscape", + userAgent: "Mozilla/5.0 (iPad; CPU OS 11_0 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) Version/11.0 Mobile/15A5341f Safari/604.1", + viewport: { + width: 1024, + height: 768, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPad (gen 6)", + userAgent: "Mozilla/5.0 (iPad; CPU OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 768, + height: 1024, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPad (gen 6) landscape", + userAgent: "Mozilla/5.0 (iPad; CPU OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 1024, + height: 768, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPad (gen 7)", + userAgent: "Mozilla/5.0 (iPad; CPU OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 810, + height: 1080, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPad (gen 7) landscape", + userAgent: "Mozilla/5.0 (iPad; CPU OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 1080, + height: 810, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPad Mini", + userAgent: "Mozilla/5.0 (iPad; CPU OS 11_0 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) Version/11.0 Mobile/15A5341f Safari/604.1", + viewport: { + width: 768, + height: 1024, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPad Mini landscape", + userAgent: "Mozilla/5.0 (iPad; CPU OS 11_0 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) Version/11.0 Mobile/15A5341f Safari/604.1", + viewport: { + width: 1024, + height: 768, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPad Pro", + userAgent: "Mozilla/5.0 (iPad; CPU OS 11_0 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) Version/11.0 Mobile/15A5341f Safari/604.1", + viewport: { + width: 1024, + height: 1366, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPad Pro landscape", + userAgent: "Mozilla/5.0 (iPad; CPU OS 11_0 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) Version/11.0 Mobile/15A5341f Safari/604.1", + viewport: { + width: 1366, + height: 1024, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPad Pro 11", + userAgent: "Mozilla/5.0 (iPad; CPU OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 834, + height: 1194, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPad Pro 11 landscape", + userAgent: "Mozilla/5.0 (iPad; CPU OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 1194, + height: 834, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 4", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 7_1_2 like Mac OS X) AppleWebKit/537.51.2 (KHTML, like Gecko) Version/7.0 Mobile/11D257 Safari/9537.53", + viewport: { + width: 320, + height: 480, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 4 landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 7_1_2 like Mac OS X) AppleWebKit/537.51.2 (KHTML, like Gecko) Version/7.0 Mobile/11D257 Safari/9537.53", + viewport: { + width: 480, + height: 320, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 5", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_1 like Mac OS X) AppleWebKit/603.1.30 (KHTML, like Gecko) Version/10.0 Mobile/14E304 Safari/602.1", + viewport: { + width: 320, + height: 568, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 5 landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_1 like Mac OS X) AppleWebKit/603.1.30 (KHTML, like Gecko) Version/10.0 Mobile/14E304 Safari/602.1", + viewport: { + width: 568, + height: 320, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 6", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 375, + height: 667, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 6 landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 667, + height: 375, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 6 Plus", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 414, + height: 736, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 6 Plus landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 736, + height: 414, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 7", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 375, + height: 667, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 7 landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 667, + height: 375, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 7 Plus", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 414, + height: 736, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 7 Plus landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 736, + height: 414, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 8", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 375, + height: 667, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 8 landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 667, + height: 375, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 8 Plus", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 414, + height: 736, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 8 Plus landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 736, + height: 414, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone SE", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_1 like Mac OS X) AppleWebKit/603.1.30 (KHTML, like Gecko) Version/10.0 Mobile/14E304 Safari/602.1", + viewport: { + width: 320, + height: 568, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone SE landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_1 like Mac OS X) AppleWebKit/603.1.30 (KHTML, like Gecko) Version/10.0 Mobile/14E304 Safari/602.1", + viewport: { + width: 568, + height: 320, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone X", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 375, + height: 812, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone X landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1", + viewport: { + width: 812, + height: 375, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone XR", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 12_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1", + viewport: { + width: 414, + height: 896, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone XR landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 12_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1", + viewport: { + width: 896, + height: 414, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 11", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1 Mobile/15E148 Safari/604.1", + viewport: { + width: 414, + height: 828, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 11 landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1 Mobile/15E148 Safari/604.1", + viewport: { + width: 828, + height: 414, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 11 Pro", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1 Mobile/15E148 Safari/604.1", + viewport: { + width: 375, + height: 812, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 11 Pro landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1 Mobile/15E148 Safari/604.1", + viewport: { + width: 812, + height: 375, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 11 Pro Max", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1 Mobile/15E148 Safari/604.1", + viewport: { + width: 414, + height: 896, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 11 Pro Max landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1 Mobile/15E148 Safari/604.1", + viewport: { + width: 896, + height: 414, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 12", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 390, + height: 844, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 12 landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 844, + height: 390, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 12 Pro", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 390, + height: 844, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 12 Pro landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 844, + height: 390, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 12 Pro Max", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 428, + height: 926, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 12 Pro Max landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 926, + height: 428, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 12 Mini", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 375, + height: 812, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 12 Mini landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 812, + height: 375, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 13", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 390, + height: 844, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 13 landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 844, + height: 390, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 13 Pro", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 390, + height: 844, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 13 Pro landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 844, + height: 390, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 13 Pro Max", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 428, + height: 926, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 13 Pro Max landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 926, + height: 428, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 13 Mini", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 375, + height: 812, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 13 Mini landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1", + viewport: { + width: 812, + height: 375, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 14", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1", + viewport: { + width: 390, + height: 663, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 14 landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1", + viewport: { + width: 750, + height: 340, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 14 Plus", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1", + viewport: { + width: 428, + height: 745, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 14 Plus landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1", + viewport: { + width: 832, + height: 378, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 14 Pro", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1", + viewport: { + width: 393, + height: 659, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 14 Pro landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1", + viewport: { + width: 734, + height: 343, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 14 Pro Max", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1", + viewport: { + width: 430, + height: 739, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 14 Pro Max landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1", + viewport: { + width: 814, + height: 380, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 15", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1", + viewport: { + width: 393, + height: 659, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 15 landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1", + viewport: { + width: 734, + height: 343, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 15 Plus", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1", + viewport: { + width: 430, + height: 739, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 15 Plus landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1", + viewport: { + width: 814, + height: 380, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 15 Pro", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1", + viewport: { + width: 393, + height: 659, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 15 Pro landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1", + viewport: { + width: 734, + height: 343, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "iPhone 15 Pro Max", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1", + viewport: { + width: 430, + height: 739, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "iPhone 15 Pro Max landscape", + userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1", + viewport: { + width: 814, + height: 380, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "JioPhone 2", + userAgent: "Mozilla/5.0 (Mobile; LYF/F300B/LYF-F300B-001-01-15-130718-i;Android; rv:48.0) Gecko/48.0 Firefox/48.0 KAIOS/2.5", + viewport: { + width: 240, + height: 320, + deviceScaleFactor: 1, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "JioPhone 2 landscape", + userAgent: "Mozilla/5.0 (Mobile; LYF/F300B/LYF-F300B-001-01-15-130718-i;Android; rv:48.0) Gecko/48.0 Firefox/48.0 KAIOS/2.5", + viewport: { + width: 320, + height: 240, + deviceScaleFactor: 1, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Kindle Fire HDX", + userAgent: "Mozilla/5.0 (Linux; U; en-us; KFAPWI Build/JDQ39) AppleWebKit/535.19 (KHTML, like Gecko) Silk/3.13 Safari/535.19 Silk-Accelerated=true", + viewport: { + width: 800, + height: 1280, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Kindle Fire HDX landscape", + userAgent: "Mozilla/5.0 (Linux; U; en-us; KFAPWI Build/JDQ39) AppleWebKit/535.19 (KHTML, like Gecko) Silk/3.13 Safari/535.19 Silk-Accelerated=true", + viewport: { + width: 1280, + height: 800, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "LG Optimus L70", + userAgent: "Mozilla/5.0 (Linux; U; Android 4.4.2; en-us; LGMS323 Build/KOT49I.MS32310c) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 384, + height: 640, + deviceScaleFactor: 1.25, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "LG Optimus L70 landscape", + userAgent: "Mozilla/5.0 (Linux; U; Android 4.4.2; en-us; LGMS323 Build/KOT49I.MS32310c) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 640, + height: 384, + deviceScaleFactor: 1.25, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Microsoft Lumia 550", + userAgent: "Mozilla/5.0 (Windows Phone 10.0; Android 4.2.1; Microsoft; Lumia 550) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2486.0 Mobile Safari/537.36 Edge/14.14263", + viewport: { + width: 640, + height: 360, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Microsoft Lumia 950", + userAgent: "Mozilla/5.0 (Windows Phone 10.0; Android 4.2.1; Microsoft; Lumia 950) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2486.0 Mobile Safari/537.36 Edge/14.14263", + viewport: { + width: 360, + height: 640, + deviceScaleFactor: 4, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Microsoft Lumia 950 landscape", + userAgent: "Mozilla/5.0 (Windows Phone 10.0; Android 4.2.1; Microsoft; Lumia 950) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2486.0 Mobile Safari/537.36 Edge/14.14263", + viewport: { + width: 640, + height: 360, + deviceScaleFactor: 4, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Nexus 10", + userAgent: "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 10 Build/MOB31T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Safari/537.36", + viewport: { + width: 800, + height: 1280, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Nexus 10 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 10 Build/MOB31T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Safari/537.36", + viewport: { + width: 1280, + height: 800, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Nexus 4", + userAgent: "Mozilla/5.0 (Linux; Android 4.4.2; Nexus 4 Build/KOT49H) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 384, + height: 640, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Nexus 4 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 4.4.2; Nexus 4 Build/KOT49H) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 640, + height: 384, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Nexus 5", + userAgent: "Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 360, + height: 640, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Nexus 5 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 640, + height: 360, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Nexus 5X", + userAgent: "Mozilla/5.0 (Linux; Android 8.0.0; Nexus 5X Build/OPR4.170623.006) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 412, + height: 732, + deviceScaleFactor: 2.625, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Nexus 5X landscape", + userAgent: "Mozilla/5.0 (Linux; Android 8.0.0; Nexus 5X Build/OPR4.170623.006) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 732, + height: 412, + deviceScaleFactor: 2.625, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Nexus 6", + userAgent: "Mozilla/5.0 (Linux; Android 7.1.1; Nexus 6 Build/N6F26U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 412, + height: 732, + deviceScaleFactor: 3.5, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Nexus 6 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 7.1.1; Nexus 6 Build/N6F26U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 732, + height: 412, + deviceScaleFactor: 3.5, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Nexus 6P", + userAgent: "Mozilla/5.0 (Linux; Android 8.0.0; Nexus 6P Build/OPP3.170518.006) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 412, + height: 732, + deviceScaleFactor: 3.5, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Nexus 6P landscape", + userAgent: "Mozilla/5.0 (Linux; Android 8.0.0; Nexus 6P Build/OPP3.170518.006) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 732, + height: 412, + deviceScaleFactor: 3.5, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Nexus 7", + userAgent: "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 7 Build/MOB30X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Safari/537.36", + viewport: { + width: 600, + height: 960, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Nexus 7 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 7 Build/MOB30X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Safari/537.36", + viewport: { + width: 960, + height: 600, + deviceScaleFactor: 2, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Nokia Lumia 520", + userAgent: "Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0; IEMobile/10.0; ARM; Touch; NOKIA; Lumia 520)", + viewport: { + width: 320, + height: 533, + deviceScaleFactor: 1.5, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Nokia Lumia 520 landscape", + userAgent: "Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0; IEMobile/10.0; ARM; Touch; NOKIA; Lumia 520)", + viewport: { + width: 533, + height: 320, + deviceScaleFactor: 1.5, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Nokia N9", + userAgent: "Mozilla/5.0 (MeeGo; NokiaN9) AppleWebKit/534.13 (KHTML, like Gecko) NokiaBrowser/8.5.0 Mobile Safari/534.13", + viewport: { + width: 480, + height: 854, + deviceScaleFactor: 1, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Nokia N9 landscape", + userAgent: "Mozilla/5.0 (MeeGo; NokiaN9) AppleWebKit/534.13 (KHTML, like Gecko) NokiaBrowser/8.5.0 Mobile Safari/534.13", + viewport: { + width: 854, + height: 480, + deviceScaleFactor: 1, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Pixel 2", + userAgent: "Mozilla/5.0 (Linux; Android 8.0; Pixel 2 Build/OPD3.170816.012) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 411, + height: 731, + deviceScaleFactor: 2.625, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Pixel 2 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 8.0; Pixel 2 Build/OPD3.170816.012) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 731, + height: 411, + deviceScaleFactor: 2.625, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Pixel 2 XL", + userAgent: "Mozilla/5.0 (Linux; Android 8.0.0; Pixel 2 XL Build/OPD1.170816.004) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 411, + height: 823, + deviceScaleFactor: 3.5, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Pixel 2 XL landscape", + userAgent: "Mozilla/5.0 (Linux; Android 8.0.0; Pixel 2 XL Build/OPD1.170816.004) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3765.0 Mobile Safari/537.36", + viewport: { + width: 823, + height: 411, + deviceScaleFactor: 3.5, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Pixel 3", + userAgent: "Mozilla/5.0 (Linux; Android 9; Pixel 3 Build/PQ1A.181105.017.A1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.158 Mobile Safari/537.36", + viewport: { + width: 393, + height: 786, + deviceScaleFactor: 2.75, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Pixel 3 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 9; Pixel 3 Build/PQ1A.181105.017.A1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.158 Mobile Safari/537.36", + viewport: { + width: 786, + height: 393, + deviceScaleFactor: 2.75, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Pixel 4", + userAgent: "Mozilla/5.0 (Linux; Android 10; Pixel 4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Mobile Safari/537.36", + viewport: { + width: 353, + height: 745, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Pixel 4 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 10; Pixel 4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Mobile Safari/537.36", + viewport: { + width: 745, + height: 353, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Pixel 4a (5G)", + userAgent: "Mozilla/5.0 (Linux; Android 11; Pixel 4a (5G)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4812.0 Mobile Safari/537.36", + viewport: { + width: 353, + height: 745, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Pixel 4a (5G) landscape", + userAgent: "Mozilla/5.0 (Linux; Android 11; Pixel 4a (5G)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4812.0 Mobile Safari/537.36", + viewport: { + width: 745, + height: 353, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Pixel 5", + userAgent: "Mozilla/5.0 (Linux; Android 11; Pixel 5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4812.0 Mobile Safari/537.36", + viewport: { + width: 393, + height: 851, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Pixel 5 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 11; Pixel 5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4812.0 Mobile Safari/537.36", + viewport: { + width: 851, + height: 393, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + }, + { + name: "Moto G4", + userAgent: "Mozilla/5.0 (Linux; Android 7.0; Moto G (4)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4812.0 Mobile Safari/537.36", + viewport: { + width: 360, + height: 640, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: false + } + }, + { + name: "Moto G4 landscape", + userAgent: "Mozilla/5.0 (Linux; Android 7.0; Moto G (4)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4812.0 Mobile Safari/537.36", + viewport: { + width: 640, + height: 360, + deviceScaleFactor: 3, + isMobile: true, + hasTouch: true, + isLandscape: true + } + } +]; +var knownDevicesByName = {}; +for (const device of knownDevices) { + knownDevicesByName[device.name] = device; +} +var KnownDevices = Object.freeze(knownDevicesByName); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/Puppeteer.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/BrowserConnector.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/bidi/BrowserConnector.js +init_cjs_shim(); +async function _connectToBiDiBrowser(connectionTransport, url, options) { + const { acceptInsecureCerts = false, defaultViewport = DEFAULT_VIEWPORT } = options; + const { bidiConnection, cdpConnection, closeCallback } = await getBiDiConnection(connectionTransport, url, options); + const BiDi = await import( + /* webpackIgnore: true */ + "./bidi-2I2CA3WT.mjs" + ); + const bidiBrowser = await BiDi.BidiBrowser.create({ + connection: bidiConnection, + cdpConnection, + closeCallback, + process: void 0, + defaultViewport, + acceptInsecureCerts, + capabilities: options.capabilities + }); + return bidiBrowser; +} +async function getBiDiConnection(connectionTransport, url, options) { + const BiDi = await import( + /* webpackIgnore: true */ + "./bidi-2I2CA3WT.mjs" + ); + const { slowMo = 0, protocolTimeout } = options; + const pureBidiConnection = new BiDi.BidiConnection(url, connectionTransport, slowMo, protocolTimeout); + try { + const result = await pureBidiConnection.send("session.status", {}); + if ("type" in result && result.type === "success") { + return { + bidiConnection: pureBidiConnection, + closeCallback: async () => { + await pureBidiConnection.send("browser.close", {}).catch(debugError); + } + }; + } + } catch (e) { + if (!(e instanceof ProtocolError)) { + throw e; + } + } + pureBidiConnection.unbind(); + const cdpConnection = new Connection(url, connectionTransport, slowMo, protocolTimeout); + const version2 = await cdpConnection.send("Browser.getVersion"); + if (version2.product.toLowerCase().includes("firefox")) { + throw new UnsupportedOperation("Firefox is not supported in BiDi over CDP mode."); + } + const bidiOverCdpConnection = await BiDi.connectBidiOverCdp(cdpConnection); + return { + cdpConnection, + bidiConnection: bidiOverCdpConnection, + closeCallback: async () => { + await cdpConnection.send("Browser.close").catch(debugError); + } + }; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/BrowserConnector.js +var getWebSocketTransportClass = async () => { + return isNode ? (await import("./NodeWebSocketTransport-UA4FKYLF.mjs")).NodeWebSocketTransport : (await import("./BrowserWebSocketTransport-VT34BAS5.mjs")).BrowserWebSocketTransport; +}; +async function _connectToBrowser(options) { + const { connectionTransport, endpointUrl } = await getConnectionTransport(options); + if (options.protocol === "webDriverBiDi") { + const bidiBrowser = await _connectToBiDiBrowser(connectionTransport, endpointUrl, options); + return bidiBrowser; + } else { + const cdpBrowser = await _connectToCdpBrowser(connectionTransport, endpointUrl, options); + return cdpBrowser; + } +} +async function getConnectionTransport(options) { + const { browserWSEndpoint, browserURL, transport, headers = {} } = options; + assert(Number(!!browserWSEndpoint) + Number(!!browserURL) + Number(!!transport) === 1, "Exactly one of browserWSEndpoint, browserURL or transport must be passed to puppeteer.connect"); + if (transport) { + return { connectionTransport: transport, endpointUrl: "" }; + } else if (browserWSEndpoint) { + const WebSocketClass = await getWebSocketTransportClass(); + const connectionTransport = await WebSocketClass.create(browserWSEndpoint, headers); + return { + connectionTransport, + endpointUrl: browserWSEndpoint + }; + } else if (browserURL) { + const connectionURL = await getWSEndpoint(browserURL); + const WebSocketClass = await getWebSocketTransportClass(); + const connectionTransport = await WebSocketClass.create(connectionURL); + return { + connectionTransport, + endpointUrl: connectionURL + }; + } + throw new Error("Invalid connection options"); +} +async function getWSEndpoint(browserURL) { + const endpointURL = new URL("/json/version", browserURL); + try { + const result = await globalThis.fetch(endpointURL.toString(), { + method: "GET" + }); + if (!result.ok) { + throw new Error(`HTTP ${result.statusText}`); + } + const data = await result.json(); + return data.webSocketDebuggerUrl; + } catch (error) { + if (isErrorLike(error)) { + error.message = `Failed to fetch browser webSocket URL from ${endpointURL}: ` + error.message; + } + throw error; + } +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/Puppeteer.js +var Puppeteer = class { + /** + * Registers a {@link CustomQueryHandler | custom query handler}. + * + * @remarks + * After registration, the handler can be used everywhere where a selector is + * expected by prepending the selection string with `/`. The name is only + * allowed to consist of lower- and upper case latin letters. + * + * @example + * + * ``` + * import {Puppeteer}, puppeteer from 'puppeteer'; + * + * Puppeteer.registerCustomQueryHandler('text', { … }); + * const aHandle = await page.$('text/…'); + * ``` + * + * @param name - The name that the custom query handler will be registered + * under. + * @param queryHandler - The {@link CustomQueryHandler | custom query handler} + * to register. + * + * @public + */ + static registerCustomQueryHandler(name, queryHandler) { + return this.customQueryHandlers.register(name, queryHandler); + } + /** + * Unregisters a custom query handler for a given name. + */ + static unregisterCustomQueryHandler(name) { + return this.customQueryHandlers.unregister(name); + } + /** + * Gets the names of all custom query handlers. + */ + static customQueryHandlerNames() { + return this.customQueryHandlers.names(); + } + /** + * Unregisters all custom query handlers. + */ + static clearCustomQueryHandlers() { + return this.customQueryHandlers.clear(); + } + /** + * @internal + */ + _isPuppeteerCore; + /** + * @internal + */ + _changedBrowsers = false; + /** + * @internal + */ + constructor(settings) { + this._isPuppeteerCore = settings.isPuppeteerCore; + this.connect = this.connect.bind(this); + } + /** + * This method attaches Puppeteer to an existing browser instance. + * + * @remarks + * + * @param options - Set of configurable options to set on the browser. + * @returns Promise which resolves to browser instance. + */ + connect(options) { + return _connectToBrowser(options); + } +}; +/** + * Operations for {@link CustomQueryHandler | custom query handlers}. See + * {@link CustomQueryHandlerRegistry}. + * + * @internal + */ +__publicField(Puppeteer, "customQueryHandlers", customQueryHandlers); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/TaskQueue.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/revisions.js +init_cjs_shim(); +var PUPPETEER_REVISIONS = Object.freeze({ + chrome: "131.0.6778.85", + "chrome-headless-shell": "131.0.6778.85", + firefox: "stable_132.0.2" +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/util/util.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/node.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/ChromeLauncher.js +init_cjs_shim(); +import { mkdtemp } from "fs/promises"; +import os5 from "os"; +import path7 from "path"; + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/main.js +init_cjs_shim(); + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/launch.js +init_cjs_shim(); +import childProcess from "child_process"; +import { accessSync } from "fs"; +import os3 from "os"; +import readline from "readline"; + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/browser-data/browser-data.js +init_cjs_shim(); + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/browser-data/chrome-headless-shell.js +init_cjs_shim(); +import path2 from "path"; + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/browser-data/types.js +init_cjs_shim(); +var Browser2; +(function(Browser3) { + Browser3["CHROME"] = "chrome"; + Browser3["CHROMEHEADLESSSHELL"] = "chrome-headless-shell"; + Browser3["CHROMIUM"] = "chromium"; + Browser3["FIREFOX"] = "firefox"; + Browser3["CHROMEDRIVER"] = "chromedriver"; +})(Browser2 || (Browser2 = {})); +var BrowserPlatform; +(function(BrowserPlatform2) { + BrowserPlatform2["LINUX"] = "linux"; + BrowserPlatform2["MAC"] = "mac"; + BrowserPlatform2["MAC_ARM"] = "mac_arm"; + BrowserPlatform2["WIN32"] = "win32"; + BrowserPlatform2["WIN64"] = "win64"; +})(BrowserPlatform || (BrowserPlatform = {})); +var BrowserTag; +(function(BrowserTag2) { + BrowserTag2["CANARY"] = "canary"; + BrowserTag2["NIGHTLY"] = "nightly"; + BrowserTag2["BETA"] = "beta"; + BrowserTag2["DEV"] = "dev"; + BrowserTag2["DEVEDITION"] = "devedition"; + BrowserTag2["STABLE"] = "stable"; + BrowserTag2["ESR"] = "esr"; + BrowserTag2["LATEST"] = "latest"; +})(BrowserTag || (BrowserTag = {})); +var ChromeReleaseChannel; +(function(ChromeReleaseChannel2) { + ChromeReleaseChannel2["STABLE"] = "stable"; + ChromeReleaseChannel2["DEV"] = "dev"; + ChromeReleaseChannel2["CANARY"] = "canary"; + ChromeReleaseChannel2["BETA"] = "beta"; +})(ChromeReleaseChannel || (ChromeReleaseChannel = {})); + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/browser-data/chrome.js +init_cjs_shim(); +var import_semver = __toESM(require_semver2(), 1); +import path from "path"; + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/httpUtil.js +init_cjs_shim(); +var import_proxy_agent = __toESM(require_dist11(), 1); +import * as http from "http"; +import * as https from "https"; +import { URL as URL2, urlToHttpOptions } from "url"; +function httpRequest(url, method, response, keepAlive = true) { + const options = { + protocol: url.protocol, + hostname: url.hostname, + port: url.port, + path: url.pathname + url.search, + method, + headers: keepAlive ? { Connection: "keep-alive" } : void 0, + auth: urlToHttpOptions(url).auth, + agent: new import_proxy_agent.ProxyAgent() + }; + const requestCallback = (res) => { + if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) { + httpRequest(new URL2(res.headers.location), method, response); + res.resume(); + } else { + response(res); + } + }; + const request3 = options.protocol === "https:" ? https.request(options, requestCallback) : http.request(options, requestCallback); + request3.end(); + return request3; +} +async function getJSON(url) { + const text = await getText(url); + try { + return JSON.parse(text); + } catch { + throw new Error("Could not parse JSON from " + url.toString()); + } +} +function getText(url) { + return new Promise((resolve5, reject) => { + const request3 = httpRequest(url, "GET", (response) => { + let data = ""; + if (response.statusCode && response.statusCode >= 400) { + return reject(new Error(`Got status code ${response.statusCode}`)); + } + response.on("data", (chunk) => { + data += chunk; + }); + response.on("end", () => { + try { + return resolve5(String(data)); + } catch { + return reject(new Error("Chrome version not found")); + } + }); + }, false); + request3.on("error", (err) => { + reject(err); + }); + }); +} + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/browser-data/chrome.js +function folder(platform) { + switch (platform) { + case BrowserPlatform.LINUX: + return "linux64"; + case BrowserPlatform.MAC_ARM: + return "mac-arm64"; + case BrowserPlatform.MAC: + return "mac-x64"; + case BrowserPlatform.WIN32: + return "win32"; + case BrowserPlatform.WIN64: + return "win64"; + } +} +function resolveDownloadUrl(platform, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") { + return `${baseUrl}/${resolveDownloadPath(platform, buildId).join("/")}`; +} +function resolveDownloadPath(platform, buildId) { + return [buildId, folder(platform), `chrome-${folder(platform)}.zip`]; +} +function relativeExecutablePath(platform, _buildId) { + switch (platform) { + case BrowserPlatform.MAC: + case BrowserPlatform.MAC_ARM: + return path.join("chrome-" + folder(platform), "Google Chrome for Testing.app", "Contents", "MacOS", "Google Chrome for Testing"); + case BrowserPlatform.LINUX: + return path.join("chrome-linux64", "chrome"); + case BrowserPlatform.WIN32: + case BrowserPlatform.WIN64: + return path.join("chrome-" + folder(platform), "chrome.exe"); + } +} +async function getLastKnownGoodReleaseForChannel(channel) { + const data = await getJSON(new URL("https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json")); + for (const channel2 of Object.keys(data.channels)) { + data.channels[channel2.toLowerCase()] = data.channels[channel2]; + delete data.channels[channel2]; + } + return data.channels[channel]; +} +async function getLastKnownGoodReleaseForMilestone(milestone) { + const data = await getJSON(new URL("https://googlechromelabs.github.io/chrome-for-testing/latest-versions-per-milestone.json")); + return data.milestones[milestone]; +} +async function getLastKnownGoodReleaseForBuild(buildPrefix) { + const data = await getJSON(new URL("https://googlechromelabs.github.io/chrome-for-testing/latest-patch-versions-per-build.json")); + return data.builds[buildPrefix]; +} +async function resolveBuildId(channel) { + if (Object.values(ChromeReleaseChannel).includes(channel)) { + return (await getLastKnownGoodReleaseForChannel(channel)).version; + } + if (channel.match(/^\d+$/)) { + return (await getLastKnownGoodReleaseForMilestone(channel))?.version; + } + if (channel.match(/^\d+\.\d+\.\d+$/)) { + return (await getLastKnownGoodReleaseForBuild(channel))?.version; + } + return; +} +function resolveSystemExecutablePath(platform, channel) { + switch (platform) { + case BrowserPlatform.WIN64: + case BrowserPlatform.WIN32: + switch (channel) { + case ChromeReleaseChannel.STABLE: + return `${process.env["PROGRAMFILES"]}\\Google\\Chrome\\Application\\chrome.exe`; + case ChromeReleaseChannel.BETA: + return `${process.env["PROGRAMFILES"]}\\Google\\Chrome Beta\\Application\\chrome.exe`; + case ChromeReleaseChannel.CANARY: + return `${process.env["PROGRAMFILES"]}\\Google\\Chrome SxS\\Application\\chrome.exe`; + case ChromeReleaseChannel.DEV: + return `${process.env["PROGRAMFILES"]}\\Google\\Chrome Dev\\Application\\chrome.exe`; + } + case BrowserPlatform.MAC_ARM: + case BrowserPlatform.MAC: + switch (channel) { + case ChromeReleaseChannel.STABLE: + return "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"; + case ChromeReleaseChannel.BETA: + return "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta"; + case ChromeReleaseChannel.CANARY: + return "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"; + case ChromeReleaseChannel.DEV: + return "/Applications/Google Chrome Dev.app/Contents/MacOS/Google Chrome Dev"; + } + case BrowserPlatform.LINUX: + switch (channel) { + case ChromeReleaseChannel.STABLE: + return "/opt/google/chrome/chrome"; + case ChromeReleaseChannel.BETA: + return "/opt/google/chrome-beta/chrome"; + case ChromeReleaseChannel.DEV: + return "/opt/google/chrome-unstable/chrome"; + } + } + throw new Error(`Unable to detect browser executable path for '${channel}' on ${platform}.`); +} +function compareVersions(a, b) { + if (!import_semver.default.valid(a)) { + throw new Error(`Version ${a} is not a valid semver version`); + } + if (!import_semver.default.valid(b)) { + throw new Error(`Version ${b} is not a valid semver version`); + } + if (import_semver.default.gt(a, b)) { + return 1; + } else if (import_semver.default.lt(a, b)) { + return -1; + } else { + return 0; + } +} + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/browser-data/chrome-headless-shell.js +function folder2(platform) { + switch (platform) { + case BrowserPlatform.LINUX: + return "linux64"; + case BrowserPlatform.MAC_ARM: + return "mac-arm64"; + case BrowserPlatform.MAC: + return "mac-x64"; + case BrowserPlatform.WIN32: + return "win32"; + case BrowserPlatform.WIN64: + return "win64"; + } +} +function resolveDownloadUrl2(platform, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") { + return `${baseUrl}/${resolveDownloadPath2(platform, buildId).join("/")}`; +} +function resolveDownloadPath2(platform, buildId) { + return [ + buildId, + folder2(platform), + `chrome-headless-shell-${folder2(platform)}.zip` + ]; +} +function relativeExecutablePath2(platform, _buildId) { + switch (platform) { + case BrowserPlatform.MAC: + case BrowserPlatform.MAC_ARM: + return path2.join("chrome-headless-shell-" + folder2(platform), "chrome-headless-shell"); + case BrowserPlatform.LINUX: + return path2.join("chrome-headless-shell-linux64", "chrome-headless-shell"); + case BrowserPlatform.WIN32: + case BrowserPlatform.WIN64: + return path2.join("chrome-headless-shell-" + folder2(platform), "chrome-headless-shell.exe"); + } +} + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/browser-data/chromedriver.js +init_cjs_shim(); +import path3 from "path"; +function folder3(platform) { + switch (platform) { + case BrowserPlatform.LINUX: + return "linux64"; + case BrowserPlatform.MAC_ARM: + return "mac-arm64"; + case BrowserPlatform.MAC: + return "mac-x64"; + case BrowserPlatform.WIN32: + return "win32"; + case BrowserPlatform.WIN64: + return "win64"; + } +} +function resolveDownloadUrl3(platform, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") { + return `${baseUrl}/${resolveDownloadPath3(platform, buildId).join("/")}`; +} +function resolveDownloadPath3(platform, buildId) { + return [buildId, folder3(platform), `chromedriver-${folder3(platform)}.zip`]; +} +function relativeExecutablePath3(platform, _buildId) { + switch (platform) { + case BrowserPlatform.MAC: + case BrowserPlatform.MAC_ARM: + return path3.join("chromedriver-" + folder3(platform), "chromedriver"); + case BrowserPlatform.LINUX: + return path3.join("chromedriver-linux64", "chromedriver"); + case BrowserPlatform.WIN32: + case BrowserPlatform.WIN64: + return path3.join("chromedriver-" + folder3(platform), "chromedriver.exe"); + } +} + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/browser-data/chromium.js +init_cjs_shim(); +import path4 from "path"; +function archive(platform, buildId) { + switch (platform) { + case BrowserPlatform.LINUX: + return "chrome-linux"; + case BrowserPlatform.MAC_ARM: + case BrowserPlatform.MAC: + return "chrome-mac"; + case BrowserPlatform.WIN32: + case BrowserPlatform.WIN64: + return parseInt(buildId, 10) > 591479 ? "chrome-win" : "chrome-win32"; + } +} +function folder4(platform) { + switch (platform) { + case BrowserPlatform.LINUX: + return "Linux_x64"; + case BrowserPlatform.MAC_ARM: + return "Mac_Arm"; + case BrowserPlatform.MAC: + return "Mac"; + case BrowserPlatform.WIN32: + return "Win"; + case BrowserPlatform.WIN64: + return "Win_x64"; + } +} +function resolveDownloadUrl4(platform, buildId, baseUrl = "https://storage.googleapis.com/chromium-browser-snapshots") { + return `${baseUrl}/${resolveDownloadPath4(platform, buildId).join("/")}`; +} +function resolveDownloadPath4(platform, buildId) { + return [folder4(platform), buildId, `${archive(platform, buildId)}.zip`]; +} +function relativeExecutablePath4(platform, _buildId) { + switch (platform) { + case BrowserPlatform.MAC: + case BrowserPlatform.MAC_ARM: + return path4.join("chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium"); + case BrowserPlatform.LINUX: + return path4.join("chrome-linux", "chrome"); + case BrowserPlatform.WIN32: + case BrowserPlatform.WIN64: + return path4.join("chrome-win", "chrome.exe"); + } +} +async function resolveBuildId2(platform) { + return await getText(new URL(`https://storage.googleapis.com/chromium-browser-snapshots/${folder4(platform)}/LAST_CHANGE`)); +} +function compareVersions2(a, b) { + return Number(a) - Number(b); +} + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/browser-data/firefox.js +init_cjs_shim(); +import fs from "fs"; +import path5 from "path"; +function archiveNightly(platform, buildId) { + switch (platform) { + case BrowserPlatform.LINUX: + return `firefox-${buildId}.en-US.${platform}-x86_64.tar.bz2`; + case BrowserPlatform.MAC_ARM: + case BrowserPlatform.MAC: + return `firefox-${buildId}.en-US.mac.dmg`; + case BrowserPlatform.WIN32: + case BrowserPlatform.WIN64: + return `firefox-${buildId}.en-US.${platform}.zip`; + } +} +function archive2(platform, buildId) { + switch (platform) { + case BrowserPlatform.LINUX: + return `firefox-${buildId}.tar.bz2`; + case BrowserPlatform.MAC_ARM: + case BrowserPlatform.MAC: + return `Firefox ${buildId}.dmg`; + case BrowserPlatform.WIN32: + case BrowserPlatform.WIN64: + return `Firefox Setup ${buildId}.exe`; + } +} +function platformName(platform) { + switch (platform) { + case BrowserPlatform.LINUX: + return `linux-x86_64`; + case BrowserPlatform.MAC_ARM: + case BrowserPlatform.MAC: + return `mac`; + case BrowserPlatform.WIN32: + case BrowserPlatform.WIN64: + return platform; + } +} +function parseBuildId(buildId) { + for (const value of Object.values(FirefoxChannel)) { + if (buildId.startsWith(value + "_")) { + buildId = buildId.substring(value.length + 1); + return [value, buildId]; + } + } + return [FirefoxChannel.NIGHTLY, buildId]; +} +function resolveDownloadUrl5(platform, buildId, baseUrl) { + const [channel] = parseBuildId(buildId); + switch (channel) { + case FirefoxChannel.NIGHTLY: + baseUrl ??= "https://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central"; + break; + case FirefoxChannel.DEVEDITION: + baseUrl ??= "https://archive.mozilla.org/pub/devedition/releases"; + break; + case FirefoxChannel.BETA: + case FirefoxChannel.STABLE: + case FirefoxChannel.ESR: + baseUrl ??= "https://archive.mozilla.org/pub/firefox/releases"; + break; + } + return `${baseUrl}/${resolveDownloadPath5(platform, buildId).join("/")}`; +} +function resolveDownloadPath5(platform, buildId) { + const [channel, resolvedBuildId] = parseBuildId(buildId); + switch (channel) { + case FirefoxChannel.NIGHTLY: + return [archiveNightly(platform, resolvedBuildId)]; + case FirefoxChannel.DEVEDITION: + case FirefoxChannel.BETA: + case FirefoxChannel.STABLE: + case FirefoxChannel.ESR: + return [ + resolvedBuildId, + platformName(platform), + "en-US", + archive2(platform, resolvedBuildId) + ]; + } +} +function relativeExecutablePath5(platform, buildId) { + const [channel] = parseBuildId(buildId); + switch (channel) { + case FirefoxChannel.NIGHTLY: + switch (platform) { + case BrowserPlatform.MAC_ARM: + case BrowserPlatform.MAC: + return path5.join("Firefox Nightly.app", "Contents", "MacOS", "firefox"); + case BrowserPlatform.LINUX: + return path5.join("firefox", "firefox"); + case BrowserPlatform.WIN32: + case BrowserPlatform.WIN64: + return path5.join("firefox", "firefox.exe"); + } + case FirefoxChannel.BETA: + case FirefoxChannel.DEVEDITION: + case FirefoxChannel.ESR: + case FirefoxChannel.STABLE: + switch (platform) { + case BrowserPlatform.MAC_ARM: + case BrowserPlatform.MAC: + return path5.join("Firefox.app", "Contents", "MacOS", "firefox"); + case BrowserPlatform.LINUX: + return path5.join("firefox", "firefox"); + case BrowserPlatform.WIN32: + case BrowserPlatform.WIN64: + return path5.join("core", "firefox.exe"); + } + } +} +var FirefoxChannel; +(function(FirefoxChannel2) { + FirefoxChannel2["STABLE"] = "stable"; + FirefoxChannel2["ESR"] = "esr"; + FirefoxChannel2["DEVEDITION"] = "devedition"; + FirefoxChannel2["BETA"] = "beta"; + FirefoxChannel2["NIGHTLY"] = "nightly"; +})(FirefoxChannel || (FirefoxChannel = {})); +async function resolveBuildId3(channel = FirefoxChannel.NIGHTLY) { + const channelToVersionKey = { + [FirefoxChannel.ESR]: "FIREFOX_ESR", + [FirefoxChannel.STABLE]: "LATEST_FIREFOX_VERSION", + [FirefoxChannel.DEVEDITION]: "FIREFOX_DEVEDITION", + [FirefoxChannel.BETA]: "FIREFOX_DEVEDITION", + [FirefoxChannel.NIGHTLY]: "FIREFOX_NIGHTLY" + }; + const versions = await getJSON(new URL("https://product-details.mozilla.org/1.0/firefox_versions.json")); + const version2 = versions[channelToVersionKey[channel]]; + if (!version2) { + throw new Error(`Channel ${channel} is not found.`); + } + return channel + "_" + version2; +} +async function createProfile(options) { + if (!fs.existsSync(options.path)) { + await fs.promises.mkdir(options.path, { + recursive: true + }); + } + await syncPreferences({ + preferences: { + ...defaultProfilePreferences(options.preferences), + ...options.preferences + }, + path: options.path + }); +} +function defaultProfilePreferences(extraPrefs) { + const server = "dummy.test"; + const defaultPrefs = { + // Make sure Shield doesn't hit the network. + "app.normandy.api_url": "", + // Disable Firefox old build background check + "app.update.checkInstallTime": false, + // Disable automatically upgrading Firefox + "app.update.disabledForTesting": true, + // Increase the APZ content response timeout to 1 minute + "apz.content_response_timeout": 6e4, + // Prevent various error message on the console + // jest-puppeteer asserts that no error message is emitted by the console + "browser.contentblocking.features.standard": "-tp,tpPrivate,cookieBehavior0,-cm,-fp", + // Enable the dump function: which sends messages to the system + // console + // https://bugzilla.mozilla.org/show_bug.cgi?id=1543115 + "browser.dom.window.dump.enabled": true, + // Disable topstories + "browser.newtabpage.activity-stream.feeds.system.topstories": false, + // Always display a blank page + "browser.newtabpage.enabled": false, + // Background thumbnails in particular cause grief: and disabling + // thumbnails in general cannot hurt + "browser.pagethumbnails.capturing_disabled": true, + // Disable safebrowsing components. + "browser.safebrowsing.blockedURIs.enabled": false, + "browser.safebrowsing.downloads.enabled": false, + "browser.safebrowsing.malware.enabled": false, + "browser.safebrowsing.phishing.enabled": false, + // Disable updates to search engines. + "browser.search.update": false, + // Do not restore the last open set of tabs if the browser has crashed + "browser.sessionstore.resume_from_crash": false, + // Skip check for default browser on startup + "browser.shell.checkDefaultBrowser": false, + // Disable newtabpage + "browser.startup.homepage": "about:blank", + // Do not redirect user when a milstone upgrade of Firefox is detected + "browser.startup.homepage_override.mstone": "ignore", + // Start with a blank page about:blank + "browser.startup.page": 0, + // Do not allow background tabs to be zombified on Android: otherwise for + // tests that open additional tabs: the test harness tab itself might get + // unloaded + "browser.tabs.disableBackgroundZombification": false, + // Do not warn when closing all other open tabs + "browser.tabs.warnOnCloseOtherTabs": false, + // Do not warn when multiple tabs will be opened + "browser.tabs.warnOnOpen": false, + // Do not automatically offer translations, as tests do not expect this. + "browser.translations.automaticallyPopup": false, + // Disable the UI tour. + "browser.uitour.enabled": false, + // Turn off search suggestions in the location bar so as not to trigger + // network connections. + "browser.urlbar.suggest.searches": false, + // Disable first run splash page on Windows 10 + "browser.usedOnWindows10.introURL": "", + // Do not warn on quitting Firefox + "browser.warnOnQuit": false, + // Defensively disable data reporting systems + "datareporting.healthreport.documentServerURI": `http://${server}/dummy/healthreport/`, + "datareporting.healthreport.logging.consoleEnabled": false, + "datareporting.healthreport.service.enabled": false, + "datareporting.healthreport.service.firstRun": false, + "datareporting.healthreport.uploadEnabled": false, + // Do not show datareporting policy notifications which can interfere with tests + "datareporting.policy.dataSubmissionEnabled": false, + "datareporting.policy.dataSubmissionPolicyBypassNotification": true, + // DevTools JSONViewer sometimes fails to load dependencies with its require.js. + // This doesn't affect Puppeteer but spams console (Bug 1424372) + "devtools.jsonview.enabled": false, + // Disable popup-blocker + "dom.disable_open_during_load": false, + // Enable the support for File object creation in the content process + // Required for |Page.setFileInputFiles| protocol method. + "dom.file.createInChild": true, + // Disable the ProcessHangMonitor + "dom.ipc.reportProcessHangs": false, + // Disable slow script dialogues + "dom.max_chrome_script_run_time": 0, + "dom.max_script_run_time": 0, + // Only load extensions from the application and user profile + // AddonManager.SCOPE_PROFILE + AddonManager.SCOPE_APPLICATION + "extensions.autoDisableScopes": 0, + "extensions.enabledScopes": 5, + // Disable metadata caching for installed add-ons by default + "extensions.getAddons.cache.enabled": false, + // Disable installing any distribution extensions or add-ons. + "extensions.installDistroAddons": false, + // Disabled screenshots extension + "extensions.screenshots.disabled": true, + // Turn off extension updates so they do not bother tests + "extensions.update.enabled": false, + // Turn off extension updates so they do not bother tests + "extensions.update.notifyUser": false, + // Make sure opening about:addons will not hit the network + "extensions.webservice.discoverURL": `http://${server}/dummy/discoveryURL`, + // Allow the application to have focus even it runs in the background + "focusmanager.testmode": true, + // Disable useragent updates + "general.useragent.updates.enabled": false, + // Always use network provider for geolocation tests so we bypass the + // macOS dialog raised by the corelocation provider + "geo.provider.testing": true, + // Do not scan Wifi + "geo.wifi.scan": false, + // No hang monitor + "hangmonitor.timeout": 0, + // Show chrome errors and warnings in the error console + "javascript.options.showInConsole": true, + // Disable download and usage of OpenH264: and Widevine plugins + "media.gmp-manager.updateEnabled": false, + // Disable the GFX sanity window + "media.sanity-test.disabled": true, + // Disable experimental feature that is only available in Nightly + "network.cookie.sameSite.laxByDefault": false, + // Do not prompt for temporary redirects + "network.http.prompt-temp-redirect": false, + // Disable speculative connections so they are not reported as leaking + // when they are hanging around + "network.http.speculative-parallel-limit": 0, + // Do not automatically switch between offline and online + "network.manage-offline-status": false, + // Make sure SNTP requests do not hit the network + "network.sntp.pools": server, + // Disable Flash. + "plugin.state.flash": 0, + "privacy.trackingprotection.enabled": false, + // Can be removed once Firefox 89 is no longer supported + // https://bugzilla.mozilla.org/show_bug.cgi?id=1710839 + "remote.enabled": true, + // Don't do network connections for mitm priming + "security.certerrors.mitm.priming.enabled": false, + // Local documents have access to all other local documents, + // including directory listings + "security.fileuri.strict_origin_policy": false, + // Do not wait for the notification button security delay + "security.notification_enable_delay": 0, + // Ensure blocklist updates do not hit the network + "services.settings.server": `http://${server}/dummy/blocklist/`, + // Do not automatically fill sign-in forms with known usernames and + // passwords + "signon.autofillForms": false, + // Disable password capture, so that tests that include forms are not + // influenced by the presence of the persistent doorhanger notification + "signon.rememberSignons": false, + // Disable first-run welcome page + "startup.homepage_welcome_url": "about:blank", + // Disable first-run welcome page + "startup.homepage_welcome_url.additional": "", + // Disable browser animations (tabs, fullscreen, sliding alerts) + "toolkit.cosmeticAnimations.enabled": false, + // Prevent starting into safe mode after application crashes + "toolkit.startup.max_resumed_crashes": -1 + }; + return Object.assign(defaultPrefs, extraPrefs); +} +async function backupFile(input) { + if (!fs.existsSync(input)) { + return; + } + await fs.promises.copyFile(input, input + ".puppeteer"); +} +async function syncPreferences(options) { + const prefsPath = path5.join(options.path, "prefs.js"); + const userPath = path5.join(options.path, "user.js"); + const lines = Object.entries(options.preferences).map(([key, value]) => { + return `user_pref(${JSON.stringify(key)}, ${JSON.stringify(value)});`; + }); + const result = await Promise.allSettled([ + backupFile(userPath).then(async () => { + await fs.promises.writeFile(userPath, lines.join("\n")); + }), + backupFile(prefsPath) + ]); + for (const command2 of result) { + if (command2.status === "rejected") { + throw command2.reason; + } + } +} +function compareVersions3(a, b) { + return parseInt(a.replace(".", ""), 16) - parseInt(b.replace(".", ""), 16); +} + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/browser-data/browser-data.js +var downloadUrls = { + [Browser2.CHROMEDRIVER]: resolveDownloadUrl3, + [Browser2.CHROMEHEADLESSSHELL]: resolveDownloadUrl2, + [Browser2.CHROME]: resolveDownloadUrl, + [Browser2.CHROMIUM]: resolveDownloadUrl4, + [Browser2.FIREFOX]: resolveDownloadUrl5 +}; +var downloadPaths = { + [Browser2.CHROMEDRIVER]: resolveDownloadPath3, + [Browser2.CHROMEHEADLESSSHELL]: resolveDownloadPath2, + [Browser2.CHROME]: resolveDownloadPath, + [Browser2.CHROMIUM]: resolveDownloadPath4, + [Browser2.FIREFOX]: resolveDownloadPath5 +}; +var executablePathByBrowser = { + [Browser2.CHROMEDRIVER]: relativeExecutablePath3, + [Browser2.CHROMEHEADLESSSHELL]: relativeExecutablePath2, + [Browser2.CHROME]: relativeExecutablePath, + [Browser2.CHROMIUM]: relativeExecutablePath4, + [Browser2.FIREFOX]: relativeExecutablePath5 +}; +var versionComparators = { + [Browser2.CHROMEDRIVER]: compareVersions, + [Browser2.CHROMEHEADLESSSHELL]: compareVersions, + [Browser2.CHROME]: compareVersions, + [Browser2.CHROMIUM]: compareVersions2, + [Browser2.FIREFOX]: compareVersions3 +}; +async function resolveBuildIdForBrowserTag(browser, platform, tag) { + switch (browser) { + case Browser2.FIREFOX: + switch (tag) { + case BrowserTag.LATEST: + return await resolveBuildId3(FirefoxChannel.NIGHTLY); + case BrowserTag.BETA: + return await resolveBuildId3(FirefoxChannel.BETA); + case BrowserTag.NIGHTLY: + return await resolveBuildId3(FirefoxChannel.NIGHTLY); + case BrowserTag.DEVEDITION: + return await resolveBuildId3(FirefoxChannel.DEVEDITION); + case BrowserTag.STABLE: + return await resolveBuildId3(FirefoxChannel.STABLE); + case BrowserTag.ESR: + return await resolveBuildId3(FirefoxChannel.ESR); + case BrowserTag.CANARY: + case BrowserTag.DEV: + throw new Error(`${tag.toUpperCase()} is not available for Firefox`); + } + case Browser2.CHROME: { + switch (tag) { + case BrowserTag.LATEST: + return await resolveBuildId(ChromeReleaseChannel.CANARY); + case BrowserTag.BETA: + return await resolveBuildId(ChromeReleaseChannel.BETA); + case BrowserTag.CANARY: + return await resolveBuildId(ChromeReleaseChannel.CANARY); + case BrowserTag.DEV: + return await resolveBuildId(ChromeReleaseChannel.DEV); + case BrowserTag.STABLE: + return await resolveBuildId(ChromeReleaseChannel.STABLE); + case BrowserTag.NIGHTLY: + case BrowserTag.DEVEDITION: + case BrowserTag.ESR: + throw new Error(`${tag.toUpperCase()} is not available for Chrome`); + } + } + case Browser2.CHROMEDRIVER: { + switch (tag) { + case BrowserTag.LATEST: + case BrowserTag.CANARY: + return await resolveBuildId(ChromeReleaseChannel.CANARY); + case BrowserTag.BETA: + return await resolveBuildId(ChromeReleaseChannel.BETA); + case BrowserTag.DEV: + return await resolveBuildId(ChromeReleaseChannel.DEV); + case BrowserTag.STABLE: + return await resolveBuildId(ChromeReleaseChannel.STABLE); + case BrowserTag.NIGHTLY: + case BrowserTag.DEVEDITION: + case BrowserTag.ESR: + throw new Error(`${tag.toUpperCase()} is not available for ChromeDriver`); + } + } + case Browser2.CHROMEHEADLESSSHELL: { + switch (tag) { + case BrowserTag.LATEST: + case BrowserTag.CANARY: + return await resolveBuildId(ChromeReleaseChannel.CANARY); + case BrowserTag.BETA: + return await resolveBuildId(ChromeReleaseChannel.BETA); + case BrowserTag.DEV: + return await resolveBuildId(ChromeReleaseChannel.DEV); + case BrowserTag.STABLE: + return await resolveBuildId(ChromeReleaseChannel.STABLE); + case BrowserTag.NIGHTLY: + case BrowserTag.DEVEDITION: + case BrowserTag.ESR: + throw new Error(`${tag} is not available for chrome-headless-shell`); + } + } + case Browser2.CHROMIUM: + switch (tag) { + case BrowserTag.LATEST: + return await resolveBuildId2(platform); + case BrowserTag.NIGHTLY: + case BrowserTag.CANARY: + case BrowserTag.DEV: + case BrowserTag.DEVEDITION: + case BrowserTag.BETA: + case BrowserTag.STABLE: + case BrowserTag.ESR: + throw new Error(`${tag} is not supported for Chromium. Use 'latest' instead.`); + } + } +} +async function resolveBuildId4(browser, platform, tag) { + const browserTag = tag; + if (Object.values(BrowserTag).includes(browserTag)) { + return await resolveBuildIdForBrowserTag(browser, platform, browserTag); + } + switch (browser) { + case Browser2.FIREFOX: + return tag; + case Browser2.CHROME: + const chromeResult = await resolveBuildId(tag); + if (chromeResult) { + return chromeResult; + } + return tag; + case Browser2.CHROMEDRIVER: + const chromeDriverResult = await resolveBuildId(tag); + if (chromeDriverResult) { + return chromeDriverResult; + } + return tag; + case Browser2.CHROMEHEADLESSSHELL: + const chromeHeadlessShellResult = await resolveBuildId(tag); + if (chromeHeadlessShellResult) { + return chromeHeadlessShellResult; + } + return tag; + case Browser2.CHROMIUM: + return tag; + } +} +async function createProfile2(browser, opts) { + switch (browser) { + case Browser2.FIREFOX: + return await createProfile(opts); + case Browser2.CHROME: + case Browser2.CHROMIUM: + throw new Error(`Profile creation is not support for ${browser} yet`); + } +} +function resolveSystemExecutablePath2(browser, platform, channel) { + switch (browser) { + case Browser2.CHROMEDRIVER: + case Browser2.CHROMEHEADLESSSHELL: + case Browser2.FIREFOX: + case Browser2.CHROMIUM: + throw new Error(`System browser detection is not supported for ${browser} yet.`); + case Browser2.CHROME: + return resolveSystemExecutablePath(platform, channel); + } +} +function getVersionComparator(browser) { + return versionComparators[browser]; +} + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/Cache.js +init_cjs_shim(); +var import_debug = __toESM(require_src(), 1); +import fs2 from "fs"; +import os2 from "os"; +import path6 from "path"; + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/detectPlatform.js +init_cjs_shim(); +import os from "os"; +function detectBrowserPlatform() { + const platform = os.platform(); + switch (platform) { + case "darwin": + return os.arch() === "arm64" ? BrowserPlatform.MAC_ARM : BrowserPlatform.MAC; + case "linux": + return BrowserPlatform.LINUX; + case "win32": + return os.arch() === "x64" || // Windows 11 for ARM supports x64 emulation + os.arch() === "arm64" && isWindows11(os.release()) ? BrowserPlatform.WIN64 : BrowserPlatform.WIN32; + default: + return void 0; + } +} +function isWindows11(version2) { + const parts = version2.split("."); + if (parts.length > 2) { + const major = parseInt(parts[0], 10); + const minor = parseInt(parts[1], 10); + const patch = parseInt(parts[2], 10); + return major > 10 || major === 10 && minor > 0 || major === 10 && minor === 0 && patch >= 22e3; + } + return false; +} + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/Cache.js +var debugCache = (0, import_debug.default)("puppeteer:browsers:cache"); +var InstalledBrowser = class { + browser; + buildId; + platform; + executablePath; + #cache; + /** + * @internal + */ + constructor(cache, browser, buildId, platform) { + this.#cache = cache; + this.browser = browser; + this.buildId = buildId; + this.platform = platform; + this.executablePath = cache.computeExecutablePath({ + browser, + buildId, + platform + }); + } + /** + * Path to the root of the installation folder. Use + * {@link computeExecutablePath} to get the path to the executable binary. + */ + get path() { + return this.#cache.installationDir(this.browser, this.platform, this.buildId); + } + readMetadata() { + return this.#cache.readMetadata(this.browser); + } + writeMetadata(metadata) { + this.#cache.writeMetadata(this.browser, metadata); + } +}; +var Cache = class { + #rootDir; + constructor(rootDir) { + this.#rootDir = rootDir; + } + /** + * @internal + */ + get rootDir() { + return this.#rootDir; + } + browserRoot(browser) { + return path6.join(this.#rootDir, browser); + } + metadataFile(browser) { + return path6.join(this.browserRoot(browser), ".metadata"); + } + readMetadata(browser) { + const metatadaPath = this.metadataFile(browser); + if (!fs2.existsSync(metatadaPath)) { + return { aliases: {} }; + } + const data = JSON.parse(fs2.readFileSync(metatadaPath, "utf8")); + if (typeof data !== "object") { + throw new Error(".metadata is not an object"); + } + return data; + } + writeMetadata(browser, metadata) { + const metatadaPath = this.metadataFile(browser); + fs2.mkdirSync(path6.dirname(metatadaPath), { recursive: true }); + fs2.writeFileSync(metatadaPath, JSON.stringify(metadata, null, 2)); + } + resolveAlias(browser, alias) { + const metadata = this.readMetadata(browser); + if (alias === "latest") { + return Object.values(metadata.aliases || {}).sort(getVersionComparator(browser)).at(-1); + } + return metadata.aliases[alias]; + } + installationDir(browser, platform, buildId) { + return path6.join(this.browserRoot(browser), `${platform}-${buildId}`); + } + clear() { + fs2.rmSync(this.#rootDir, { + force: true, + recursive: true, + maxRetries: 10, + retryDelay: 500 + }); + } + uninstall(browser, platform, buildId) { + const metadata = this.readMetadata(browser); + for (const alias of Object.keys(metadata.aliases)) { + if (metadata.aliases[alias] === buildId) { + delete metadata.aliases[alias]; + } + } + fs2.rmSync(this.installationDir(browser, platform, buildId), { + force: true, + recursive: true, + maxRetries: 10, + retryDelay: 500 + }); + } + getInstalledBrowsers() { + if (!fs2.existsSync(this.#rootDir)) { + return []; + } + const types = fs2.readdirSync(this.#rootDir); + const browsers = types.filter((t) => { + return Object.values(Browser2).includes(t); + }); + return browsers.flatMap((browser) => { + const files = fs2.readdirSync(this.browserRoot(browser)); + return files.map((file) => { + const result = parseFolderPath(path6.join(this.browserRoot(browser), file)); + if (!result) { + return null; + } + return new InstalledBrowser(this, browser, result.buildId, result.platform); + }).filter((item) => { + return item !== null; + }); + }); + } + computeExecutablePath(options) { + options.platform ??= detectBrowserPlatform(); + if (!options.platform) { + throw new Error(`Cannot download a binary for the provided platform: ${os2.platform()} (${os2.arch()})`); + } + try { + options.buildId = this.resolveAlias(options.browser, options.buildId) ?? options.buildId; + } catch { + debugCache("could not read .metadata file for the browser"); + } + const installationDir = this.installationDir(options.browser, options.platform, options.buildId); + return path6.join(installationDir, executablePathByBrowser[options.browser](options.platform, options.buildId)); + } +}; +function parseFolderPath(folderPath) { + const name = path6.basename(folderPath); + const splits = name.split("-"); + if (splits.length !== 2) { + return; + } + const [platform, buildId] = splits; + if (!buildId || !platform) { + return; + } + return { platform, buildId }; +} + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/debug.js +init_cjs_shim(); +var import_debug2 = __toESM(require_src(), 1); + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/launch.js +var debugLaunch = (0, import_debug2.default)("puppeteer:browsers:launcher"); +function computeExecutablePath(options) { + return new Cache(options.cacheDir).computeExecutablePath(options); +} +function computeSystemExecutablePath(options) { + options.platform ??= detectBrowserPlatform(); + if (!options.platform) { + throw new Error(`Cannot download a binary for the provided platform: ${os3.platform()} (${os3.arch()})`); + } + const path10 = resolveSystemExecutablePath2(options.browser, options.platform, options.channel); + try { + accessSync(path10); + } catch { + throw new Error(`Could not find Google Chrome executable for channel '${options.channel}' at '${path10}'.`); + } + return path10; +} +function launch(opts) { + return new Process(opts); +} +var CDP_WEBSOCKET_ENDPOINT_REGEX = /^DevTools listening on (ws:\/\/.*)$/; +var WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX = /^WebDriver BiDi listening on (ws:\/\/.*)$/; +var processListeners = /* @__PURE__ */ new Map(); +var dispatchers = { + exit: (...args) => { + processListeners.get("exit")?.forEach((handler) => { + return handler(...args); + }); + }, + SIGINT: (...args) => { + processListeners.get("SIGINT")?.forEach((handler) => { + return handler(...args); + }); + }, + SIGHUP: (...args) => { + processListeners.get("SIGHUP")?.forEach((handler) => { + return handler(...args); + }); + }, + SIGTERM: (...args) => { + processListeners.get("SIGTERM")?.forEach((handler) => { + return handler(...args); + }); + } +}; +function subscribeToProcessEvent(event, handler) { + const listeners = processListeners.get(event) || []; + if (listeners.length === 0) { + process.on(event, dispatchers[event]); + } + listeners.push(handler); + processListeners.set(event, listeners); +} +function unsubscribeFromProcessEvent(event, handler) { + const listeners = processListeners.get(event) || []; + const existingListenerIdx = listeners.indexOf(handler); + if (existingListenerIdx === -1) { + return; + } + listeners.splice(existingListenerIdx, 1); + processListeners.set(event, listeners); + if (listeners.length === 0) { + process.off(event, dispatchers[event]); + } +} +var Process = class { + #executablePath; + #args; + #browserProcess; + #exited = false; + // The browser process can be closed externally or from the driver process. We + // need to invoke the hooks only once though but we don't know how many times + // we will be invoked. + #hooksRan = false; + #onExitHook = async () => { + }; + #browserProcessExiting; + constructor(opts) { + this.#executablePath = opts.executablePath; + this.#args = opts.args ?? []; + opts.pipe ??= false; + opts.dumpio ??= false; + opts.handleSIGINT ??= true; + opts.handleSIGTERM ??= true; + opts.handleSIGHUP ??= true; + opts.detached ??= process.platform !== "win32"; + const stdio = this.#configureStdio({ + pipe: opts.pipe, + dumpio: opts.dumpio + }); + const env2 = opts.env || {}; + debugLaunch(`Launching ${this.#executablePath} ${this.#args.join(" ")}`, { + detached: opts.detached, + env: Object.keys(env2).reduce((res, key) => { + if (key.toLowerCase().startsWith("puppeteer_")) { + res[key] = env2[key]; + } + return res; + }, {}), + stdio + }); + this.#browserProcess = childProcess.spawn(this.#executablePath, this.#args, { + detached: opts.detached, + env: env2, + stdio + }); + debugLaunch(`Launched ${this.#browserProcess.pid}`); + if (opts.dumpio) { + this.#browserProcess.stderr?.pipe(process.stderr); + this.#browserProcess.stdout?.pipe(process.stdout); + } + subscribeToProcessEvent("exit", this.#onDriverProcessExit); + if (opts.handleSIGINT) { + subscribeToProcessEvent("SIGINT", this.#onDriverProcessSignal); + } + if (opts.handleSIGTERM) { + subscribeToProcessEvent("SIGTERM", this.#onDriverProcessSignal); + } + if (opts.handleSIGHUP) { + subscribeToProcessEvent("SIGHUP", this.#onDriverProcessSignal); + } + if (opts.onExit) { + this.#onExitHook = opts.onExit; + } + this.#browserProcessExiting = new Promise((resolve5, reject) => { + this.#browserProcess.once("exit", async () => { + debugLaunch(`Browser process ${this.#browserProcess.pid} onExit`); + this.#clearListeners(); + this.#exited = true; + try { + await this.#runHooks(); + } catch (err) { + reject(err); + return; + } + resolve5(); + }); + }); + } + async #runHooks() { + if (this.#hooksRan) { + return; + } + this.#hooksRan = true; + await this.#onExitHook(); + } + get nodeProcess() { + return this.#browserProcess; + } + #configureStdio(opts) { + if (opts.pipe) { + if (opts.dumpio) { + return ["ignore", "pipe", "pipe", "pipe", "pipe"]; + } else { + return ["ignore", "ignore", "ignore", "pipe", "pipe"]; + } + } else { + if (opts.dumpio) { + return ["pipe", "pipe", "pipe"]; + } else { + return ["pipe", "ignore", "pipe"]; + } + } + } + #clearListeners() { + unsubscribeFromProcessEvent("exit", this.#onDriverProcessExit); + unsubscribeFromProcessEvent("SIGINT", this.#onDriverProcessSignal); + unsubscribeFromProcessEvent("SIGTERM", this.#onDriverProcessSignal); + unsubscribeFromProcessEvent("SIGHUP", this.#onDriverProcessSignal); + } + #onDriverProcessExit = (_code) => { + this.kill(); + }; + #onDriverProcessSignal = (signal) => { + switch (signal) { + case "SIGINT": + this.kill(); + process.exit(130); + case "SIGTERM": + case "SIGHUP": + void this.close(); + break; + } + }; + async close() { + await this.#runHooks(); + if (!this.#exited) { + this.kill(); + } + return await this.#browserProcessExiting; + } + hasClosed() { + return this.#browserProcessExiting; + } + kill() { + debugLaunch(`Trying to kill ${this.#browserProcess.pid}`); + if (this.#browserProcess && this.#browserProcess.pid && pidExists(this.#browserProcess.pid)) { + try { + debugLaunch(`Browser process ${this.#browserProcess.pid} exists`); + if (process.platform === "win32") { + try { + childProcess.execSync(`taskkill /pid ${this.#browserProcess.pid} /T /F`); + } catch (error) { + debugLaunch(`Killing ${this.#browserProcess.pid} using taskkill failed`, error); + this.#browserProcess.kill(); + } + } else { + const processGroupId = -this.#browserProcess.pid; + try { + process.kill(processGroupId, "SIGKILL"); + } catch (error) { + debugLaunch(`Killing ${this.#browserProcess.pid} using process.kill failed`, error); + this.#browserProcess.kill("SIGKILL"); + } + } + } catch (error) { + throw new Error(`${PROCESS_ERROR_EXPLANATION} +Error cause: ${isErrorLike2(error) ? error.stack : error}`); + } + } + this.#clearListeners(); + } + waitForLineOutput(regex, timeout2 = 0) { + if (!this.#browserProcess.stderr) { + throw new Error("`browserProcess` does not have stderr."); + } + const rl = readline.createInterface(this.#browserProcess.stderr); + let stderr = ""; + return new Promise((resolve5, reject) => { + rl.on("line", onLine); + rl.on("close", onClose); + this.#browserProcess.on("exit", onClose); + this.#browserProcess.on("error", onClose); + const timeoutId = timeout2 > 0 ? setTimeout(onTimeout, timeout2) : void 0; + const cleanup = () => { + if (timeoutId) { + clearTimeout(timeoutId); + } + rl.off("line", onLine); + rl.off("close", onClose); + this.#browserProcess.off("exit", onClose); + this.#browserProcess.off("error", onClose); + }; + function onClose(error) { + cleanup(); + reject(new Error([ + `Failed to launch the browser process!${error ? " " + error.message : ""}`, + stderr, + "", + "TROUBLESHOOTING: https://pptr.dev/troubleshooting", + "" + ].join("\n"))); + } + function onTimeout() { + cleanup(); + reject(new TimeoutError2(`Timed out after ${timeout2} ms while waiting for the WS endpoint URL to appear in stdout!`)); + } + function onLine(line) { + stderr += line + "\n"; + const match = line.match(regex); + if (!match) { + return; + } + cleanup(); + resolve5(match[1]); + } + }); + } +}; +var PROCESS_ERROR_EXPLANATION = `Puppeteer was unable to kill the process which ran the browser binary. +This means that, on future Puppeteer launches, Puppeteer might not be able to launch the browser. +Please check your open processes and ensure that the browser processes that Puppeteer launched have been killed. +If you think this is a bug, please report it on the Puppeteer issue tracker.`; +function pidExists(pid) { + try { + return process.kill(pid, 0); + } catch (error) { + if (isErrnoException(error)) { + if (error.code && error.code === "ESRCH") { + return false; + } + } + throw error; + } +} +function isErrorLike2(obj) { + return typeof obj === "object" && obj !== null && "name" in obj && "message" in obj; +} +function isErrnoException(obj) { + return isErrorLike2(obj) && ("errno" in obj || "code" in obj || "path" in obj || "syscall" in obj); +} +var TimeoutError2 = class extends Error { + /** + * @internal + */ + constructor(message) { + super(message); + this.name = this.constructor.name; + Error.captureStackTrace(this, this.constructor); + } +}; + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/install.js +init_cjs_shim(); +import os4 from "os"; + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/fileUtil.js +init_cjs_shim(); +var import_extract_zip = __toESM(require_extract_zip(), 1); +var import_tar_fs = __toESM(require_tar_fs(), 1); +var import_unbzip2_stream = __toESM(require_unbzip2_stream(), 1); + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/install.js +var debugInstall = (0, import_debug2.default)("puppeteer:browsers:install"); +async function uninstall(options) { + options.platform ??= detectBrowserPlatform(); + if (!options.platform) { + throw new Error(`Cannot detect the browser platform for: ${os4.platform()} (${os4.arch()})`); + } + new Cache(options.cacheDir).uninstall(options.browser, options.platform, options.buildId); +} +async function getInstalledBrowsers(options) { + return new Cache(options.cacheDir).getInstalledBrowsers(); +} + +// ../testeranto/node_modules/@puppeteer/browsers/lib/esm/CLI.js +init_cjs_shim(); +var import_progress = __toESM(require_progress(), 1); + +// ../testeranto/node_modules/yargs/index.mjs +init_cjs_shim(); + +// ../testeranto/node_modules/yargs/lib/platform-shims/esm.mjs +init_cjs_shim(); +import { notStrictEqual, strictEqual } from "assert"; + +// ../testeranto/node_modules/cliui/index.mjs +init_cjs_shim(); + +// ../testeranto/node_modules/cliui/build/lib/index.js +init_cjs_shim(); +var align = { + right: alignRight, + center: alignCenter +}; +var top = 0; +var right = 1; +var bottom = 2; +var left = 3; +var UI = class { + constructor(opts) { + var _a2; + this.width = opts.width; + this.wrap = (_a2 = opts.wrap) !== null && _a2 !== void 0 ? _a2 : true; + this.rows = []; + } + span(...args) { + const cols = this.div(...args); + cols.span = true; + } + resetOutput() { + this.rows = []; + } + div(...args) { + if (args.length === 0) { + this.div(""); + } + if (this.wrap && this.shouldApplyLayoutDSL(...args) && typeof args[0] === "string") { + return this.applyLayoutDSL(args[0]); + } + const cols = args.map((arg) => { + if (typeof arg === "string") { + return this.colFromString(arg); + } + return arg; + }); + this.rows.push(cols); + return cols; + } + shouldApplyLayoutDSL(...args) { + return args.length === 1 && typeof args[0] === "string" && /[\t\n]/.test(args[0]); + } + applyLayoutDSL(str) { + const rows = str.split("\n").map((row) => row.split(" ")); + let leftColumnWidth = 0; + rows.forEach((columns) => { + if (columns.length > 1 && mixin.stringWidth(columns[0]) > leftColumnWidth) { + leftColumnWidth = Math.min(Math.floor(this.width * 0.5), mixin.stringWidth(columns[0])); + } + }); + rows.forEach((columns) => { + this.div(...columns.map((r, i) => { + return { + text: r.trim(), + padding: this.measurePadding(r), + width: i === 0 && columns.length > 1 ? leftColumnWidth : void 0 + }; + })); + }); + return this.rows[this.rows.length - 1]; + } + colFromString(text) { + return { + text, + padding: this.measurePadding(text) + }; + } + measurePadding(str) { + const noAnsi = mixin.stripAnsi(str); + return [0, noAnsi.match(/\s*$/)[0].length, 0, noAnsi.match(/^\s*/)[0].length]; + } + toString() { + const lines = []; + this.rows.forEach((row) => { + this.rowToString(row, lines); + }); + return lines.filter((line) => !line.hidden).map((line) => line.text).join("\n"); + } + rowToString(row, lines) { + this.rasterize(row).forEach((rrow, r) => { + let str = ""; + rrow.forEach((col, c) => { + const { width } = row[c]; + const wrapWidth = this.negatePadding(row[c]); + let ts = col; + if (wrapWidth > mixin.stringWidth(col)) { + ts += " ".repeat(wrapWidth - mixin.stringWidth(col)); + } + if (row[c].align && row[c].align !== "left" && this.wrap) { + const fn = align[row[c].align]; + ts = fn(ts, wrapWidth); + if (mixin.stringWidth(ts) < wrapWidth) { + ts += " ".repeat((width || 0) - mixin.stringWidth(ts) - 1); + } + } + const padding = row[c].padding || [0, 0, 0, 0]; + if (padding[left]) { + str += " ".repeat(padding[left]); + } + str += addBorder(row[c], ts, "| "); + str += ts; + str += addBorder(row[c], ts, " |"); + if (padding[right]) { + str += " ".repeat(padding[right]); + } + if (r === 0 && lines.length > 0) { + str = this.renderInline(str, lines[lines.length - 1]); + } + }); + lines.push({ + text: str.replace(/ +$/, ""), + span: row.span + }); + }); + return lines; + } + // if the full 'source' can render in + // the target line, do so. + renderInline(source, previousLine) { + const match = source.match(/^ */); + const leadingWhitespace = match ? match[0].length : 0; + const target = previousLine.text; + const targetTextWidth = mixin.stringWidth(target.trimRight()); + if (!previousLine.span) { + return source; + } + if (!this.wrap) { + previousLine.hidden = true; + return target + source; + } + if (leadingWhitespace < targetTextWidth) { + return source; + } + previousLine.hidden = true; + return target.trimRight() + " ".repeat(leadingWhitespace - targetTextWidth) + source.trimLeft(); + } + rasterize(row) { + const rrows = []; + const widths = this.columnWidths(row); + let wrapped; + row.forEach((col, c) => { + col.width = widths[c]; + if (this.wrap) { + wrapped = mixin.wrap(col.text, this.negatePadding(col), { hard: true }).split("\n"); + } else { + wrapped = col.text.split("\n"); + } + if (col.border) { + wrapped.unshift("." + "-".repeat(this.negatePadding(col) + 2) + "."); + wrapped.push("'" + "-".repeat(this.negatePadding(col) + 2) + "'"); + } + if (col.padding) { + wrapped.unshift(...new Array(col.padding[top] || 0).fill("")); + wrapped.push(...new Array(col.padding[bottom] || 0).fill("")); + } + wrapped.forEach((str, r) => { + if (!rrows[r]) { + rrows.push([]); + } + const rrow = rrows[r]; + for (let i = 0; i < c; i++) { + if (rrow[i] === void 0) { + rrow.push(""); + } + } + rrow.push(str); + }); + }); + return rrows; + } + negatePadding(col) { + let wrapWidth = col.width || 0; + if (col.padding) { + wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0); + } + if (col.border) { + wrapWidth -= 4; + } + return wrapWidth; + } + columnWidths(row) { + if (!this.wrap) { + return row.map((col) => { + return col.width || mixin.stringWidth(col.text); + }); + } + let unset = row.length; + let remainingWidth = this.width; + const widths = row.map((col) => { + if (col.width) { + unset--; + remainingWidth -= col.width; + return col.width; + } + return void 0; + }); + const unsetWidth = unset ? Math.floor(remainingWidth / unset) : 0; + return widths.map((w, i) => { + if (w === void 0) { + return Math.max(unsetWidth, _minWidth(row[i])); + } + return w; + }); + } +}; +function addBorder(col, ts, style) { + if (col.border) { + if (/[.']-+[.']/.test(ts)) { + return ""; + } + if (ts.trim().length !== 0) { + return style; + } + return " "; + } + return ""; +} +function _minWidth(col) { + const padding = col.padding || []; + const minWidth = 1 + (padding[left] || 0) + (padding[right] || 0); + if (col.border) { + return minWidth + 4; + } + return minWidth; +} +function getWindowWidth() { + if (typeof process === "object" && process.stdout && process.stdout.columns) { + return process.stdout.columns; + } + return 80; +} +function alignRight(str, width) { + str = str.trim(); + const strWidth = mixin.stringWidth(str); + if (strWidth < width) { + return " ".repeat(width - strWidth) + str; + } + return str; +} +function alignCenter(str, width) { + str = str.trim(); + const strWidth = mixin.stringWidth(str); + if (strWidth >= width) { + return str; + } + return " ".repeat(width - strWidth >> 1) + str; +} +var mixin; +function cliui(opts, _mixin) { + mixin = _mixin; + return new UI({ + width: (opts === null || opts === void 0 ? void 0 : opts.width) || getWindowWidth(), + wrap: opts === null || opts === void 0 ? void 0 : opts.wrap + }); +} + +// ../testeranto/node_modules/cliui/build/lib/string-utils.js +init_cjs_shim(); +var ansi = new RegExp("\x1B(?:\\[(?:\\d+[ABCDEFGJKSTm]|\\d+;\\d+[Hfm]|\\d+;\\d+;\\d+m|6n|s|u|\\?25[lh])|\\w)", "g"); +function stripAnsi(str) { + return str.replace(ansi, ""); +} +function wrap(str, width) { + const [start, end] = str.match(ansi) || ["", ""]; + str = stripAnsi(str); + let wrapped = ""; + for (let i = 0; i < str.length; i++) { + if (i !== 0 && i % width === 0) { + wrapped += "\n"; + } + wrapped += str.charAt(i); + } + if (start && end) { + wrapped = `${start}${wrapped}${end}`; + } + return wrapped; +} + +// ../testeranto/node_modules/cliui/index.mjs +function ui(opts) { + return cliui(opts, { + stringWidth: (str) => { + return [...str].length; + }, + stripAnsi, + wrap + }); +} + +// ../testeranto/node_modules/escalade/sync/index.mjs +init_cjs_shim(); +import { dirname, resolve } from "path"; +import { readdirSync, statSync } from "fs"; +function sync_default(start, callback) { + let dir = resolve(".", start); + let tmp, stats = statSync(dir); + if (!stats.isDirectory()) { + dir = dirname(dir); + } + while (true) { + tmp = callback(dir, readdirSync(dir)); + if (tmp) + return resolve(dir, tmp); + dir = dirname(tmp = dir); + if (tmp === dir) + break; + } +} + +// ../testeranto/node_modules/yargs/lib/platform-shims/esm.mjs +import { inspect } from "util"; +import { readFileSync as readFileSync3 } from "fs"; +import { fileURLToPath } from "url"; + +// ../testeranto/node_modules/yargs-parser/build/lib/index.js +init_cjs_shim(); +import { format } from "util"; +import { normalize, resolve as resolve2 } from "path"; + +// ../testeranto/node_modules/yargs-parser/build/lib/string-utils.js +init_cjs_shim(); +function camelCase(str) { + const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase(); + if (!isCamelCase) { + str = str.toLowerCase(); + } + if (str.indexOf("-") === -1 && str.indexOf("_") === -1) { + return str; + } else { + let camelcase = ""; + let nextChrUpper = false; + const leadingHyphens = str.match(/^-+/); + for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) { + let chr = str.charAt(i); + if (nextChrUpper) { + nextChrUpper = false; + chr = chr.toUpperCase(); + } + if (i !== 0 && (chr === "-" || chr === "_")) { + nextChrUpper = true; + } else if (chr !== "-" && chr !== "_") { + camelcase += chr; + } + } + return camelcase; + } +} +function decamelize(str, joinString) { + const lowercase = str.toLowerCase(); + joinString = joinString || "-"; + let notCamelcase = ""; + for (let i = 0; i < str.length; i++) { + const chrLower = lowercase.charAt(i); + const chrString = str.charAt(i); + if (chrLower !== chrString && i > 0) { + notCamelcase += `${joinString}${lowercase.charAt(i)}`; + } else { + notCamelcase += chrString; + } + } + return notCamelcase; +} +function looksLikeNumber(x) { + if (x === null || x === void 0) + return false; + if (typeof x === "number") + return true; + if (/^0x[0-9a-f]+$/i.test(x)) + return true; + if (/^0[^.]/.test(x)) + return false; + return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x); +} + +// ../testeranto/node_modules/yargs-parser/build/lib/yargs-parser.js +init_cjs_shim(); + +// ../testeranto/node_modules/yargs-parser/build/lib/tokenize-arg-string.js +init_cjs_shim(); +function tokenizeArgString(argString) { + if (Array.isArray(argString)) { + return argString.map((e) => typeof e !== "string" ? e + "" : e); + } + argString = argString.trim(); + let i = 0; + let prevC = null; + let c = null; + let opening = null; + const args = []; + for (let ii = 0; ii < argString.length; ii++) { + prevC = c; + c = argString.charAt(ii); + if (c === " " && !opening) { + if (!(prevC === " ")) { + i++; + } + continue; + } + if (c === opening) { + opening = null; + } else if ((c === "'" || c === '"') && !opening) { + opening = c; + } + if (!args[i]) + args[i] = ""; + args[i] += c; + } + return args; +} + +// ../testeranto/node_modules/yargs-parser/build/lib/yargs-parser-types.js +init_cjs_shim(); +var DefaultValuesForTypeKey; +(function(DefaultValuesForTypeKey2) { + DefaultValuesForTypeKey2["BOOLEAN"] = "boolean"; + DefaultValuesForTypeKey2["STRING"] = "string"; + DefaultValuesForTypeKey2["NUMBER"] = "number"; + DefaultValuesForTypeKey2["ARRAY"] = "array"; +})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {})); + +// ../testeranto/node_modules/yargs-parser/build/lib/yargs-parser.js +var mixin2; +var YargsParser = class { + constructor(_mixin) { + mixin2 = _mixin; + } + parse(argsInput, options) { + const opts = Object.assign({ + alias: void 0, + array: void 0, + boolean: void 0, + config: void 0, + configObjects: void 0, + configuration: void 0, + coerce: void 0, + count: void 0, + default: void 0, + envPrefix: void 0, + narg: void 0, + normalize: void 0, + string: void 0, + number: void 0, + __: void 0, + key: void 0 + }, options); + const args = tokenizeArgString(argsInput); + const inputIsString = typeof argsInput === "string"; + const aliases = combineAliases(Object.assign(/* @__PURE__ */ Object.create(null), opts.alias)); + const configuration = Object.assign({ + "boolean-negation": true, + "camel-case-expansion": true, + "combine-arrays": false, + "dot-notation": true, + "duplicate-arguments-array": true, + "flatten-duplicate-arrays": true, + "greedy-arrays": true, + "halt-at-non-option": false, + "nargs-eats-options": false, + "negation-prefix": "no-", + "parse-numbers": true, + "parse-positional-numbers": true, + "populate--": false, + "set-placeholder-key": false, + "short-option-groups": true, + "strip-aliased": false, + "strip-dashed": false, + "unknown-options-as-args": false + }, opts.configuration); + const defaults = Object.assign(/* @__PURE__ */ Object.create(null), opts.default); + const configObjects = opts.configObjects || []; + const envPrefix = opts.envPrefix; + const notFlagsOption = configuration["populate--"]; + const notFlagsArgv = notFlagsOption ? "--" : "_"; + const newAliases = /* @__PURE__ */ Object.create(null); + const defaulted = /* @__PURE__ */ Object.create(null); + const __ = opts.__ || mixin2.format; + const flags = { + aliases: /* @__PURE__ */ Object.create(null), + arrays: /* @__PURE__ */ Object.create(null), + bools: /* @__PURE__ */ Object.create(null), + strings: /* @__PURE__ */ Object.create(null), + numbers: /* @__PURE__ */ Object.create(null), + counts: /* @__PURE__ */ Object.create(null), + normalize: /* @__PURE__ */ Object.create(null), + configs: /* @__PURE__ */ Object.create(null), + nargs: /* @__PURE__ */ Object.create(null), + coercions: /* @__PURE__ */ Object.create(null), + keys: [] + }; + const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/; + const negatedBoolean = new RegExp("^--" + configuration["negation-prefix"] + "(.+)"); + [].concat(opts.array || []).filter(Boolean).forEach(function(opt) { + const key = typeof opt === "object" ? opt.key : opt; + const assignment = Object.keys(opt).map(function(key2) { + const arrayFlagKeys = { + boolean: "bools", + string: "strings", + number: "numbers" + }; + return arrayFlagKeys[key2]; + }).filter(Boolean).pop(); + if (assignment) { + flags[assignment][key] = true; + } + flags.arrays[key] = true; + flags.keys.push(key); + }); + [].concat(opts.boolean || []).filter(Boolean).forEach(function(key) { + flags.bools[key] = true; + flags.keys.push(key); + }); + [].concat(opts.string || []).filter(Boolean).forEach(function(key) { + flags.strings[key] = true; + flags.keys.push(key); + }); + [].concat(opts.number || []).filter(Boolean).forEach(function(key) { + flags.numbers[key] = true; + flags.keys.push(key); + }); + [].concat(opts.count || []).filter(Boolean).forEach(function(key) { + flags.counts[key] = true; + flags.keys.push(key); + }); + [].concat(opts.normalize || []).filter(Boolean).forEach(function(key) { + flags.normalize[key] = true; + flags.keys.push(key); + }); + if (typeof opts.narg === "object") { + Object.entries(opts.narg).forEach(([key, value]) => { + if (typeof value === "number") { + flags.nargs[key] = value; + flags.keys.push(key); + } + }); + } + if (typeof opts.coerce === "object") { + Object.entries(opts.coerce).forEach(([key, value]) => { + if (typeof value === "function") { + flags.coercions[key] = value; + flags.keys.push(key); + } + }); + } + if (typeof opts.config !== "undefined") { + if (Array.isArray(opts.config) || typeof opts.config === "string") { + ; + [].concat(opts.config).filter(Boolean).forEach(function(key) { + flags.configs[key] = true; + }); + } else if (typeof opts.config === "object") { + Object.entries(opts.config).forEach(([key, value]) => { + if (typeof value === "boolean" || typeof value === "function") { + flags.configs[key] = value; + } + }); + } + } + extendAliases(opts.key, aliases, opts.default, flags.arrays); + Object.keys(defaults).forEach(function(key) { + (flags.aliases[key] || []).forEach(function(alias) { + defaults[alias] = defaults[key]; + }); + }); + let error = null; + checkConfiguration(); + let notFlags = []; + const argv = Object.assign(/* @__PURE__ */ Object.create(null), { _: [] }); + const argvReturn = {}; + for (let i = 0; i < args.length; i++) { + const arg = args[i]; + const truncatedArg = arg.replace(/^-{3,}/, "---"); + let broken; + let key; + let letters; + let m; + let next; + let value; + if (arg !== "--" && /^-/.test(arg) && isUnknownOptionAsArg(arg)) { + pushPositional(arg); + } else if (truncatedArg.match(/^---+(=|$)/)) { + pushPositional(arg); + continue; + } else if (arg.match(/^--.+=/) || !configuration["short-option-groups"] && arg.match(/^-.+=/)) { + m = arg.match(/^--?([^=]+)=([\s\S]*)$/); + if (m !== null && Array.isArray(m) && m.length >= 3) { + if (checkAllAliases(m[1], flags.arrays)) { + i = eatArray(i, m[1], args, m[2]); + } else if (checkAllAliases(m[1], flags.nargs) !== false) { + i = eatNargs(i, m[1], args, m[2]); + } else { + setArg(m[1], m[2], true); + } + } + } else if (arg.match(negatedBoolean) && configuration["boolean-negation"]) { + m = arg.match(negatedBoolean); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false); + } + } else if (arg.match(/^--.+/) || !configuration["short-option-groups"] && arg.match(/^-[^-]+/)) { + m = arg.match(/^--?(.+)/); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + if (checkAllAliases(key, flags.arrays)) { + i = eatArray(i, key, args); + } else if (checkAllAliases(key, flags.nargs) !== false) { + i = eatNargs(i, key, args); + } else { + next = args[i + 1]; + if (next !== void 0 && (!next.match(/^-/) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } else if (/^(true|false)$/.test(next)) { + setArg(key, next); + i++; + } else { + setArg(key, defaultValue(key)); + } + } + } + } else if (arg.match(/^-.\..+=/)) { + m = arg.match(/^-([^=]+)=([\s\S]*)$/); + if (m !== null && Array.isArray(m) && m.length >= 3) { + setArg(m[1], m[2]); + } + } else if (arg.match(/^-.\..+/) && !arg.match(negative)) { + next = args[i + 1]; + m = arg.match(/^-(.\..+)/); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + if (next !== void 0 && !next.match(/^-/) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } else { + setArg(key, defaultValue(key)); + } + } + } else if (arg.match(/^-[^-]+/) && !arg.match(negative)) { + letters = arg.slice(1, -1).split(""); + broken = false; + for (let j = 0; j < letters.length; j++) { + next = arg.slice(j + 2); + if (letters[j + 1] && letters[j + 1] === "=") { + value = arg.slice(j + 3); + key = letters[j]; + if (checkAllAliases(key, flags.arrays)) { + i = eatArray(i, key, args, value); + } else if (checkAllAliases(key, flags.nargs) !== false) { + i = eatNargs(i, key, args, value); + } else { + setArg(key, value); + } + broken = true; + break; + } + if (next === "-") { + setArg(letters[j], next); + continue; + } + if (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) && checkAllAliases(next, flags.bools) === false) { + setArg(letters[j], next); + broken = true; + break; + } + if (letters[j + 1] && letters[j + 1].match(/\W/)) { + setArg(letters[j], next); + broken = true; + break; + } else { + setArg(letters[j], defaultValue(letters[j])); + } + } + key = arg.slice(-1)[0]; + if (!broken && key !== "-") { + if (checkAllAliases(key, flags.arrays)) { + i = eatArray(i, key, args); + } else if (checkAllAliases(key, flags.nargs) !== false) { + i = eatNargs(i, key, args); + } else { + next = args[i + 1]; + if (next !== void 0 && (!/^(-|--)[^-]/.test(next) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } else if (/^(true|false)$/.test(next)) { + setArg(key, next); + i++; + } else { + setArg(key, defaultValue(key)); + } + } + } + } else if (arg.match(/^-[0-9]$/) && arg.match(negative) && checkAllAliases(arg.slice(1), flags.bools)) { + key = arg.slice(1); + setArg(key, defaultValue(key)); + } else if (arg === "--") { + notFlags = args.slice(i + 1); + break; + } else if (configuration["halt-at-non-option"]) { + notFlags = args.slice(i); + break; + } else { + pushPositional(arg); + } + } + applyEnvVars(argv, true); + applyEnvVars(argv, false); + setConfig(argv); + setConfigObjects(); + applyDefaultsAndAliases(argv, flags.aliases, defaults, true); + applyCoercions(argv); + if (configuration["set-placeholder-key"]) + setPlaceholderKeys(argv); + Object.keys(flags.counts).forEach(function(key) { + if (!hasKey(argv, key.split("."))) + setArg(key, 0); + }); + if (notFlagsOption && notFlags.length) + argv[notFlagsArgv] = []; + notFlags.forEach(function(key) { + argv[notFlagsArgv].push(key); + }); + if (configuration["camel-case-expansion"] && configuration["strip-dashed"]) { + Object.keys(argv).filter((key) => key !== "--" && key.includes("-")).forEach((key) => { + delete argv[key]; + }); + } + if (configuration["strip-aliased"]) { + ; + [].concat(...Object.keys(aliases).map((k) => aliases[k])).forEach((alias) => { + if (configuration["camel-case-expansion"] && alias.includes("-")) { + delete argv[alias.split(".").map((prop) => camelCase(prop)).join(".")]; + } + delete argv[alias]; + }); + } + function pushPositional(arg) { + const maybeCoercedNumber = maybeCoerceNumber("_", arg); + if (typeof maybeCoercedNumber === "string" || typeof maybeCoercedNumber === "number") { + argv._.push(maybeCoercedNumber); + } + } + function eatNargs(i, key, args2, argAfterEqualSign) { + let ii; + let toEat = checkAllAliases(key, flags.nargs); + toEat = typeof toEat !== "number" || isNaN(toEat) ? 1 : toEat; + if (toEat === 0) { + if (!isUndefined(argAfterEqualSign)) { + error = Error(__("Argument unexpected for: %s", key)); + } + setArg(key, defaultValue(key)); + return i; + } + let available = isUndefined(argAfterEqualSign) ? 0 : 1; + if (configuration["nargs-eats-options"]) { + if (args2.length - (i + 1) + available < toEat) { + error = Error(__("Not enough arguments following: %s", key)); + } + available = toEat; + } else { + for (ii = i + 1; ii < args2.length; ii++) { + if (!args2[ii].match(/^-[^0-9]/) || args2[ii].match(negative) || isUnknownOptionAsArg(args2[ii])) + available++; + else + break; + } + if (available < toEat) + error = Error(__("Not enough arguments following: %s", key)); + } + let consumed = Math.min(available, toEat); + if (!isUndefined(argAfterEqualSign) && consumed > 0) { + setArg(key, argAfterEqualSign); + consumed--; + } + for (ii = i + 1; ii < consumed + i + 1; ii++) { + setArg(key, args2[ii]); + } + return i + consumed; + } + function eatArray(i, key, args2, argAfterEqualSign) { + let argsToSet = []; + let next = argAfterEqualSign || args2[i + 1]; + const nargsCount = checkAllAliases(key, flags.nargs); + if (checkAllAliases(key, flags.bools) && !/^(true|false)$/.test(next)) { + argsToSet.push(true); + } else if (isUndefined(next) || isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) { + if (defaults[key] !== void 0) { + const defVal = defaults[key]; + argsToSet = Array.isArray(defVal) ? defVal : [defVal]; + } + } else { + if (!isUndefined(argAfterEqualSign)) { + argsToSet.push(processValue(key, argAfterEqualSign, true)); + } + for (let ii = i + 1; ii < args2.length; ii++) { + if (!configuration["greedy-arrays"] && argsToSet.length > 0 || nargsCount && typeof nargsCount === "number" && argsToSet.length >= nargsCount) + break; + next = args2[ii]; + if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) + break; + i = ii; + argsToSet.push(processValue(key, next, inputIsString)); + } + } + if (typeof nargsCount === "number" && (nargsCount && argsToSet.length < nargsCount || isNaN(nargsCount) && argsToSet.length === 0)) { + error = Error(__("Not enough arguments following: %s", key)); + } + setArg(key, argsToSet); + return i; + } + function setArg(key, val, shouldStripQuotes = inputIsString) { + if (/-/.test(key) && configuration["camel-case-expansion"]) { + const alias = key.split(".").map(function(prop) { + return camelCase(prop); + }).join("."); + addNewAlias(key, alias); + } + const value = processValue(key, val, shouldStripQuotes); + const splitKey = key.split("."); + setKey(argv, splitKey, value); + if (flags.aliases[key]) { + flags.aliases[key].forEach(function(x) { + const keyProperties = x.split("."); + setKey(argv, keyProperties, value); + }); + } + if (splitKey.length > 1 && configuration["dot-notation"]) { + ; + (flags.aliases[splitKey[0]] || []).forEach(function(x) { + let keyProperties = x.split("."); + const a = [].concat(splitKey); + a.shift(); + keyProperties = keyProperties.concat(a); + if (!(flags.aliases[key] || []).includes(keyProperties.join("."))) { + setKey(argv, keyProperties, value); + } + }); + } + if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) { + const keys = [key].concat(flags.aliases[key] || []); + keys.forEach(function(key2) { + Object.defineProperty(argvReturn, key2, { + enumerable: true, + get() { + return val; + }, + set(value2) { + val = typeof value2 === "string" ? mixin2.normalize(value2) : value2; + } + }); + }); + } + } + function addNewAlias(key, alias) { + if (!(flags.aliases[key] && flags.aliases[key].length)) { + flags.aliases[key] = [alias]; + newAliases[alias] = true; + } + if (!(flags.aliases[alias] && flags.aliases[alias].length)) { + addNewAlias(alias, key); + } + } + function processValue(key, val, shouldStripQuotes) { + if (shouldStripQuotes) { + val = stripQuotes(val); + } + if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) { + if (typeof val === "string") + val = val === "true"; + } + let value = Array.isArray(val) ? val.map(function(v) { + return maybeCoerceNumber(key, v); + }) : maybeCoerceNumber(key, val); + if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === "boolean")) { + value = increment(); + } + if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) { + if (Array.isArray(val)) + value = val.map((val2) => { + return mixin2.normalize(val2); + }); + else + value = mixin2.normalize(val); + } + return value; + } + function maybeCoerceNumber(key, value) { + if (!configuration["parse-positional-numbers"] && key === "_") + return value; + if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) { + const shouldCoerceNumber = looksLikeNumber(value) && configuration["parse-numbers"] && Number.isSafeInteger(Math.floor(parseFloat(`${value}`))); + if (shouldCoerceNumber || !isUndefined(value) && checkAllAliases(key, flags.numbers)) { + value = Number(value); + } + } + return value; + } + function setConfig(argv2) { + const configLookup = /* @__PURE__ */ Object.create(null); + applyDefaultsAndAliases(configLookup, flags.aliases, defaults); + Object.keys(flags.configs).forEach(function(configKey) { + const configPath = argv2[configKey] || configLookup[configKey]; + if (configPath) { + try { + let config2 = null; + const resolvedConfigPath = mixin2.resolve(mixin2.cwd(), configPath); + const resolveConfig = flags.configs[configKey]; + if (typeof resolveConfig === "function") { + try { + config2 = resolveConfig(resolvedConfigPath); + } catch (e) { + config2 = e; + } + if (config2 instanceof Error) { + error = config2; + return; + } + } else { + config2 = mixin2.require(resolvedConfigPath); + } + setConfigObject(config2); + } catch (ex) { + if (ex.name === "PermissionDenied") + error = ex; + else if (argv2[configKey]) + error = Error(__("Invalid JSON config file: %s", configPath)); + } + } + }); + } + function setConfigObject(config2, prev) { + Object.keys(config2).forEach(function(key) { + const value = config2[key]; + const fullKey = prev ? prev + "." + key : key; + if (typeof value === "object" && value !== null && !Array.isArray(value) && configuration["dot-notation"]) { + setConfigObject(value, fullKey); + } else { + if (!hasKey(argv, fullKey.split(".")) || checkAllAliases(fullKey, flags.arrays) && configuration["combine-arrays"]) { + setArg(fullKey, value); + } + } + }); + } + function setConfigObjects() { + if (typeof configObjects !== "undefined") { + configObjects.forEach(function(configObject) { + setConfigObject(configObject); + }); + } + } + function applyEnvVars(argv2, configOnly) { + if (typeof envPrefix === "undefined") + return; + const prefix = typeof envPrefix === "string" ? envPrefix : ""; + const env2 = mixin2.env(); + Object.keys(env2).forEach(function(envVar) { + if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) { + const keys = envVar.split("__").map(function(key, i) { + if (i === 0) { + key = key.substring(prefix.length); + } + return camelCase(key); + }); + if ((configOnly && flags.configs[keys.join(".")] || !configOnly) && !hasKey(argv2, keys)) { + setArg(keys.join("."), env2[envVar]); + } + } + }); + } + function applyCoercions(argv2) { + let coerce; + const applied = /* @__PURE__ */ new Set(); + Object.keys(argv2).forEach(function(key) { + if (!applied.has(key)) { + coerce = checkAllAliases(key, flags.coercions); + if (typeof coerce === "function") { + try { + const value = maybeCoerceNumber(key, coerce(argv2[key])); + [].concat(flags.aliases[key] || [], key).forEach((ali) => { + applied.add(ali); + argv2[ali] = value; + }); + } catch (err) { + error = err; + } + } + } + }); + } + function setPlaceholderKeys(argv2) { + flags.keys.forEach((key) => { + if (~key.indexOf(".")) + return; + if (typeof argv2[key] === "undefined") + argv2[key] = void 0; + }); + return argv2; + } + function applyDefaultsAndAliases(obj, aliases2, defaults2, canLog = false) { + Object.keys(defaults2).forEach(function(key) { + if (!hasKey(obj, key.split("."))) { + setKey(obj, key.split("."), defaults2[key]); + if (canLog) + defaulted[key] = true; + (aliases2[key] || []).forEach(function(x) { + if (hasKey(obj, x.split("."))) + return; + setKey(obj, x.split("."), defaults2[key]); + }); + } + }); + } + function hasKey(obj, keys) { + let o = obj; + if (!configuration["dot-notation"]) + keys = [keys.join(".")]; + keys.slice(0, -1).forEach(function(key2) { + o = o[key2] || {}; + }); + const key = keys[keys.length - 1]; + if (typeof o !== "object") + return false; + else + return key in o; + } + function setKey(obj, keys, value) { + let o = obj; + if (!configuration["dot-notation"]) + keys = [keys.join(".")]; + keys.slice(0, -1).forEach(function(key2) { + key2 = sanitizeKey(key2); + if (typeof o === "object" && o[key2] === void 0) { + o[key2] = {}; + } + if (typeof o[key2] !== "object" || Array.isArray(o[key2])) { + if (Array.isArray(o[key2])) { + o[key2].push({}); + } else { + o[key2] = [o[key2], {}]; + } + o = o[key2][o[key2].length - 1]; + } else { + o = o[key2]; + } + }); + const key = sanitizeKey(keys[keys.length - 1]); + const isTypeArray = checkAllAliases(keys.join("."), flags.arrays); + const isValueArray = Array.isArray(value); + let duplicate = configuration["duplicate-arguments-array"]; + if (!duplicate && checkAllAliases(key, flags.nargs)) { + duplicate = true; + if (!isUndefined(o[key]) && flags.nargs[key] === 1 || Array.isArray(o[key]) && o[key].length === flags.nargs[key]) { + o[key] = void 0; + } + } + if (value === increment()) { + o[key] = increment(o[key]); + } else if (Array.isArray(o[key])) { + if (duplicate && isTypeArray && isValueArray) { + o[key] = configuration["flatten-duplicate-arrays"] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]); + } else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) { + o[key] = value; + } else { + o[key] = o[key].concat([value]); + } + } else if (o[key] === void 0 && isTypeArray) { + o[key] = isValueArray ? value : [value]; + } else if (duplicate && !(o[key] === void 0 || checkAllAliases(key, flags.counts) || checkAllAliases(key, flags.bools))) { + o[key] = [o[key], value]; + } else { + o[key] = value; + } + } + function extendAliases(...args2) { + args2.forEach(function(obj) { + Object.keys(obj || {}).forEach(function(key) { + if (flags.aliases[key]) + return; + flags.aliases[key] = [].concat(aliases[key] || []); + flags.aliases[key].concat(key).forEach(function(x) { + if (/-/.test(x) && configuration["camel-case-expansion"]) { + const c = camelCase(x); + if (c !== key && flags.aliases[key].indexOf(c) === -1) { + flags.aliases[key].push(c); + newAliases[c] = true; + } + } + }); + flags.aliases[key].concat(key).forEach(function(x) { + if (x.length > 1 && /[A-Z]/.test(x) && configuration["camel-case-expansion"]) { + const c = decamelize(x, "-"); + if (c !== key && flags.aliases[key].indexOf(c) === -1) { + flags.aliases[key].push(c); + newAliases[c] = true; + } + } + }); + flags.aliases[key].forEach(function(x) { + flags.aliases[x] = [key].concat(flags.aliases[key].filter(function(y) { + return x !== y; + })); + }); + }); + }); + } + function checkAllAliases(key, flag) { + const toCheck = [].concat(flags.aliases[key] || [], key); + const keys = Object.keys(flag); + const setAlias = toCheck.find((key2) => keys.includes(key2)); + return setAlias ? flag[setAlias] : false; + } + function hasAnyFlag(key) { + const flagsKeys = Object.keys(flags); + const toCheck = [].concat(flagsKeys.map((k) => flags[k])); + return toCheck.some(function(flag) { + return Array.isArray(flag) ? flag.includes(key) : flag[key]; + }); + } + function hasFlagsMatching(arg, ...patterns) { + const toCheck = [].concat(...patterns); + return toCheck.some(function(pattern) { + const match = arg.match(pattern); + return match && hasAnyFlag(match[1]); + }); + } + function hasAllShortFlags(arg) { + if (arg.match(negative) || !arg.match(/^-[^-]+/)) { + return false; + } + let hasAllFlags = true; + let next; + const letters = arg.slice(1).split(""); + for (let j = 0; j < letters.length; j++) { + next = arg.slice(j + 2); + if (!hasAnyFlag(letters[j])) { + hasAllFlags = false; + break; + } + if (letters[j + 1] && letters[j + 1] === "=" || next === "-" || /[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) || letters[j + 1] && letters[j + 1].match(/\W/)) { + break; + } + } + return hasAllFlags; + } + function isUnknownOptionAsArg(arg) { + return configuration["unknown-options-as-args"] && isUnknownOption(arg); + } + function isUnknownOption(arg) { + arg = arg.replace(/^-{3,}/, "--"); + if (arg.match(negative)) { + return false; + } + if (hasAllShortFlags(arg)) { + return false; + } + const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/; + const normalFlag = /^-+([^=]+?)$/; + const flagEndingInHyphen = /^-+([^=]+?)-$/; + const flagEndingInDigits = /^-+([^=]+?\d+)$/; + const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/; + return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters); + } + function defaultValue(key) { + if (!checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts) && `${key}` in defaults) { + return defaults[key]; + } else { + return defaultForType(guessType2(key)); + } + } + function defaultForType(type) { + const def = { + [DefaultValuesForTypeKey.BOOLEAN]: true, + [DefaultValuesForTypeKey.STRING]: "", + [DefaultValuesForTypeKey.NUMBER]: void 0, + [DefaultValuesForTypeKey.ARRAY]: [] + }; + return def[type]; + } + function guessType2(key) { + let type = DefaultValuesForTypeKey.BOOLEAN; + if (checkAllAliases(key, flags.strings)) + type = DefaultValuesForTypeKey.STRING; + else if (checkAllAliases(key, flags.numbers)) + type = DefaultValuesForTypeKey.NUMBER; + else if (checkAllAliases(key, flags.bools)) + type = DefaultValuesForTypeKey.BOOLEAN; + else if (checkAllAliases(key, flags.arrays)) + type = DefaultValuesForTypeKey.ARRAY; + return type; + } + function isUndefined(num) { + return num === void 0; + } + function checkConfiguration() { + Object.keys(flags.counts).find((key) => { + if (checkAllAliases(key, flags.arrays)) { + error = Error(__("Invalid configuration: %s, opts.count excludes opts.array.", key)); + return true; + } else if (checkAllAliases(key, flags.nargs)) { + error = Error(__("Invalid configuration: %s, opts.count excludes opts.narg.", key)); + return true; + } + return false; + }); + } + return { + aliases: Object.assign({}, flags.aliases), + argv: Object.assign(argvReturn, argv), + configuration, + defaulted: Object.assign({}, defaulted), + error, + newAliases: Object.assign({}, newAliases) + }; + } +}; +function combineAliases(aliases) { + const aliasArrays = []; + const combined = /* @__PURE__ */ Object.create(null); + let change = true; + Object.keys(aliases).forEach(function(key) { + aliasArrays.push([].concat(aliases[key], key)); + }); + while (change) { + change = false; + for (let i = 0; i < aliasArrays.length; i++) { + for (let ii = i + 1; ii < aliasArrays.length; ii++) { + const intersect = aliasArrays[i].filter(function(v) { + return aliasArrays[ii].indexOf(v) !== -1; + }); + if (intersect.length) { + aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]); + aliasArrays.splice(ii, 1); + change = true; + break; + } + } + } + } + aliasArrays.forEach(function(aliasArray) { + aliasArray = aliasArray.filter(function(v, i, self2) { + return self2.indexOf(v) === i; + }); + const lastAlias = aliasArray.pop(); + if (lastAlias !== void 0 && typeof lastAlias === "string") { + combined[lastAlias] = aliasArray; + } + }); + return combined; +} +function increment(orig) { + return orig !== void 0 ? orig + 1 : 1; +} +function sanitizeKey(key) { + if (key === "__proto__") + return "___proto___"; + return key; +} +function stripQuotes(val) { + return typeof val === "string" && (val[0] === "'" || val[0] === '"') && val[val.length - 1] === val[0] ? val.substring(1, val.length - 1) : val; +} + +// ../testeranto/node_modules/yargs-parser/build/lib/index.js +import { readFileSync } from "fs"; +var _a; +var _b; +var _c; +var minNodeVersion = process && process.env && process.env.YARGS_MIN_NODE_VERSION ? Number(process.env.YARGS_MIN_NODE_VERSION) : 12; +var nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1); +if (nodeVersion) { + const major = Number(nodeVersion.match(/^([^.]+)/)[1]); + if (major < minNodeVersion) { + throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`); + } +} +var env = process ? process.env : {}; +var parser = new YargsParser({ + cwd: process.cwd, + env: () => { + return env; + }, + format, + normalize, + resolve: resolve2, + // TODO: figure out a way to combine ESM and CJS coverage, such that + // we can exercise all the lines below: + require: (path10) => { + if (typeof __require !== "undefined") { + return __require(path10); + } else if (path10.match(/\.json$/)) { + return JSON.parse(readFileSync(path10, "utf8")); + } else { + throw Error("only .json config files are supported in ESM"); + } + } +}); +var yargsParser = function Parser(args, opts) { + const result = parser.parse(args.slice(), opts); + return result.argv; +}; +yargsParser.detailed = function(args, opts) { + return parser.parse(args.slice(), opts); +}; +yargsParser.camelCase = camelCase; +yargsParser.decamelize = decamelize; +yargsParser.looksLikeNumber = looksLikeNumber; +var lib_default = yargsParser; + +// ../testeranto/node_modules/yargs/lib/platform-shims/esm.mjs +import { basename, dirname as dirname2, extname, relative, resolve as resolve4 } from "path"; + +// ../testeranto/node_modules/yargs/build/lib/utils/process-argv.js +init_cjs_shim(); +function getProcessArgvBinIndex() { + if (isBundledElectronApp()) + return 0; + return 1; +} +function isBundledElectronApp() { + return isElectronApp() && !process.defaultApp; +} +function isElectronApp() { + return !!process.versions.electron; +} +function getProcessArgvBin() { + return process.argv[getProcessArgvBinIndex()]; +} + +// ../testeranto/node_modules/yargs/build/lib/yerror.js +init_cjs_shim(); +var YError = class extends Error { + constructor(msg) { + super(msg || "yargs error"); + this.name = "YError"; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, YError); + } + } +}; + +// ../testeranto/node_modules/y18n/index.mjs +init_cjs_shim(); + +// ../testeranto/node_modules/y18n/build/lib/platform-shims/node.js +init_cjs_shim(); +import { readFileSync as readFileSync2, statSync as statSync2, writeFile } from "fs"; +import { format as format2 } from "util"; +import { resolve as resolve3 } from "path"; +var node_default = { + fs: { + readFileSync: readFileSync2, + writeFile + }, + format: format2, + resolve: resolve3, + exists: (file) => { + try { + return statSync2(file).isFile(); + } catch (err) { + return false; + } + } +}; + +// ../testeranto/node_modules/y18n/build/lib/index.js +init_cjs_shim(); +var shim; +var Y18N = class { + constructor(opts) { + opts = opts || {}; + this.directory = opts.directory || "./locales"; + this.updateFiles = typeof opts.updateFiles === "boolean" ? opts.updateFiles : true; + this.locale = opts.locale || "en"; + this.fallbackToLanguage = typeof opts.fallbackToLanguage === "boolean" ? opts.fallbackToLanguage : true; + this.cache = /* @__PURE__ */ Object.create(null); + this.writeQueue = []; + } + __(...args) { + if (typeof arguments[0] !== "string") { + return this._taggedLiteral(arguments[0], ...arguments); + } + const str = args.shift(); + let cb = function() { + }; + if (typeof args[args.length - 1] === "function") + cb = args.pop(); + cb = cb || function() { + }; + if (!this.cache[this.locale]) + this._readLocaleFile(); + if (!this.cache[this.locale][str] && this.updateFiles) { + this.cache[this.locale][str] = str; + this._enqueueWrite({ + directory: this.directory, + locale: this.locale, + cb + }); + } else { + cb(); + } + return shim.format.apply(shim.format, [this.cache[this.locale][str] || str].concat(args)); + } + __n() { + const args = Array.prototype.slice.call(arguments); + const singular = args.shift(); + const plural = args.shift(); + const quantity = args.shift(); + let cb = function() { + }; + if (typeof args[args.length - 1] === "function") + cb = args.pop(); + if (!this.cache[this.locale]) + this._readLocaleFile(); + let str = quantity === 1 ? singular : plural; + if (this.cache[this.locale][singular]) { + const entry = this.cache[this.locale][singular]; + str = entry[quantity === 1 ? "one" : "other"]; + } + if (!this.cache[this.locale][singular] && this.updateFiles) { + this.cache[this.locale][singular] = { + one: singular, + other: plural + }; + this._enqueueWrite({ + directory: this.directory, + locale: this.locale, + cb + }); + } else { + cb(); + } + const values = [str]; + if (~str.indexOf("%d")) + values.push(quantity); + return shim.format.apply(shim.format, values.concat(args)); + } + setLocale(locale) { + this.locale = locale; + } + getLocale() { + return this.locale; + } + updateLocale(obj) { + if (!this.cache[this.locale]) + this._readLocaleFile(); + for (const key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + this.cache[this.locale][key] = obj[key]; + } + } + } + _taggedLiteral(parts, ...args) { + let str = ""; + parts.forEach(function(part, i) { + const arg = args[i + 1]; + str += part; + if (typeof arg !== "undefined") { + str += "%s"; + } + }); + return this.__.apply(this, [str].concat([].slice.call(args, 1))); + } + _enqueueWrite(work) { + this.writeQueue.push(work); + if (this.writeQueue.length === 1) + this._processWriteQueue(); + } + _processWriteQueue() { + const _this = this; + const work = this.writeQueue[0]; + const directory = work.directory; + const locale = work.locale; + const cb = work.cb; + const languageFile = this._resolveLocaleFile(directory, locale); + const serializedLocale = JSON.stringify(this.cache[locale], null, 2); + shim.fs.writeFile(languageFile, serializedLocale, "utf-8", function(err) { + _this.writeQueue.shift(); + if (_this.writeQueue.length > 0) + _this._processWriteQueue(); + cb(err); + }); + } + _readLocaleFile() { + let localeLookup = {}; + const languageFile = this._resolveLocaleFile(this.directory, this.locale); + try { + if (shim.fs.readFileSync) { + localeLookup = JSON.parse(shim.fs.readFileSync(languageFile, "utf-8")); + } + } catch (err) { + if (err instanceof SyntaxError) { + err.message = "syntax error in " + languageFile; + } + if (err.code === "ENOENT") + localeLookup = {}; + else + throw err; + } + this.cache[this.locale] = localeLookup; + } + _resolveLocaleFile(directory, locale) { + let file = shim.resolve(directory, "./", locale + ".json"); + if (this.fallbackToLanguage && !this._fileExistsSync(file) && ~locale.lastIndexOf("_")) { + const languageFile = shim.resolve(directory, "./", locale.split("_")[0] + ".json"); + if (this._fileExistsSync(languageFile)) + file = languageFile; + } + return file; + } + _fileExistsSync(file) { + return shim.exists(file); + } +}; +function y18n(opts, _shim) { + shim = _shim; + const y18n3 = new Y18N(opts); + return { + __: y18n3.__.bind(y18n3), + __n: y18n3.__n.bind(y18n3), + setLocale: y18n3.setLocale.bind(y18n3), + getLocale: y18n3.getLocale.bind(y18n3), + updateLocale: y18n3.updateLocale.bind(y18n3), + locale: y18n3.locale + }; +} + +// ../testeranto/node_modules/y18n/index.mjs +var y18n2 = (opts) => { + return y18n(opts, node_default); +}; +var y18n_default = y18n2; + +// ../testeranto/node_modules/yargs/lib/platform-shims/esm.mjs +var REQUIRE_ERROR = "require is not supported by ESM"; +var REQUIRE_DIRECTORY_ERROR = "loading a directory of commands is not supported yet for ESM"; +var __dirname2; +try { + __dirname2 = fileURLToPath(import.meta.url); +} catch (e) { + __dirname2 = process.cwd(); +} +var mainFilename = __dirname2.substring(0, __dirname2.lastIndexOf("node_modules")); +var esm_default = { + assert: { + notStrictEqual, + strictEqual + }, + cliui: ui, + findUp: sync_default, + getEnv: (key) => { + return process.env[key]; + }, + inspect, + getCallerFile: () => { + throw new YError(REQUIRE_DIRECTORY_ERROR); + }, + getProcessArgvBin, + mainFilename: mainFilename || process.cwd(), + Parser: lib_default, + path: { + basename, + dirname: dirname2, + extname, + relative, + resolve: resolve4 + }, + process: { + argv: () => process.argv, + cwd: process.cwd, + emitWarning: (warning, type) => process.emitWarning(warning, type), + execPath: () => process.execPath, + exit: process.exit, + nextTick: process.nextTick, + stdColumns: typeof process.stdout.columns !== "undefined" ? process.stdout.columns : null + }, + readFileSync: readFileSync3, + require: () => { + throw new YError(REQUIRE_ERROR); + }, + requireDirectory: () => { + throw new YError(REQUIRE_DIRECTORY_ERROR); + }, + stringWidth: (str) => { + return [...str].length; + }, + y18n: y18n_default({ + directory: resolve4(__dirname2, "../../../locales"), + updateFiles: false + }) +}; + +// ../testeranto/node_modules/yargs/build/lib/yargs-factory.js +init_cjs_shim(); + +// ../testeranto/node_modules/yargs/build/lib/command.js +init_cjs_shim(); + +// ../testeranto/node_modules/yargs/build/lib/typings/common-types.js +init_cjs_shim(); +function assertNotStrictEqual(actual, expected, shim3, message) { + shim3.assert.notStrictEqual(actual, expected, message); +} +function assertSingleKey(actual, shim3) { + shim3.assert.strictEqual(typeof actual, "string"); +} +function objectKeys(object) { + return Object.keys(object); +} + +// ../testeranto/node_modules/yargs/build/lib/utils/is-promise.js +init_cjs_shim(); +function isPromise(maybePromise) { + return !!maybePromise && !!maybePromise.then && typeof maybePromise.then === "function"; +} + +// ../testeranto/node_modules/yargs/build/lib/middleware.js +init_cjs_shim(); + +// ../testeranto/node_modules/yargs/build/lib/argsert.js +init_cjs_shim(); + +// ../testeranto/node_modules/yargs/build/lib/parse-command.js +init_cjs_shim(); +function parseCommand(cmd) { + const extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, " "); + const splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/); + const bregex = /\.*[\][<>]/g; + const firstCommand = splitCommand.shift(); + if (!firstCommand) + throw new Error(`No command found in: ${cmd}`); + const parsedCommand = { + cmd: firstCommand.replace(bregex, ""), + demanded: [], + optional: [] + }; + splitCommand.forEach((cmd2, i) => { + let variadic = false; + cmd2 = cmd2.replace(/\s/g, ""); + if (/\.+[\]>]/.test(cmd2) && i === splitCommand.length - 1) + variadic = true; + if (/^\[/.test(cmd2)) { + parsedCommand.optional.push({ + cmd: cmd2.replace(bregex, "").split("|"), + variadic + }); + } else { + parsedCommand.demanded.push({ + cmd: cmd2.replace(bregex, "").split("|"), + variadic + }); + } + }); + return parsedCommand; +} + +// ../testeranto/node_modules/yargs/build/lib/argsert.js +var positionName = ["first", "second", "third", "fourth", "fifth", "sixth"]; +function argsert(arg1, arg2, arg3) { + function parseArgs() { + return typeof arg1 === "object" ? [{ demanded: [], optional: [] }, arg1, arg2] : [ + parseCommand(`cmd ${arg1}`), + arg2, + arg3 + ]; + } + try { + let position = 0; + const [parsed, callerArguments, _length] = parseArgs(); + const args = [].slice.call(callerArguments); + while (args.length && args[args.length - 1] === void 0) + args.pop(); + const length = _length || args.length; + if (length < parsed.demanded.length) { + throw new YError(`Not enough arguments provided. Expected ${parsed.demanded.length} but received ${args.length}.`); + } + const totalCommands = parsed.demanded.length + parsed.optional.length; + if (length > totalCommands) { + throw new YError(`Too many arguments provided. Expected max ${totalCommands} but received ${length}.`); + } + parsed.demanded.forEach((demanded) => { + const arg = args.shift(); + const observedType = guessType(arg); + const matchingTypes = demanded.cmd.filter((type) => type === observedType || type === "*"); + if (matchingTypes.length === 0) + argumentTypeError(observedType, demanded.cmd, position); + position += 1; + }); + parsed.optional.forEach((optional) => { + if (args.length === 0) + return; + const arg = args.shift(); + const observedType = guessType(arg); + const matchingTypes = optional.cmd.filter((type) => type === observedType || type === "*"); + if (matchingTypes.length === 0) + argumentTypeError(observedType, optional.cmd, position); + position += 1; + }); + } catch (err) { + console.warn(err.stack); + } +} +function guessType(arg) { + if (Array.isArray(arg)) { + return "array"; + } else if (arg === null) { + return "null"; + } + return typeof arg; +} +function argumentTypeError(observedType, allowedTypes, position) { + throw new YError(`Invalid ${positionName[position] || "manyith"} argument. Expected ${allowedTypes.join(" or ")} but received ${observedType}.`); +} + +// ../testeranto/node_modules/yargs/build/lib/middleware.js +var GlobalMiddleware = class { + constructor(yargs) { + this.globalMiddleware = []; + this.frozens = []; + this.yargs = yargs; + } + addMiddleware(callback, applyBeforeValidation, global2 = true, mutates = false) { + argsert(" [boolean] [boolean] [boolean]", [callback, applyBeforeValidation, global2], arguments.length); + if (Array.isArray(callback)) { + for (let i = 0; i < callback.length; i++) { + if (typeof callback[i] !== "function") { + throw Error("middleware must be a function"); + } + const m = callback[i]; + m.applyBeforeValidation = applyBeforeValidation; + m.global = global2; + } + Array.prototype.push.apply(this.globalMiddleware, callback); + } else if (typeof callback === "function") { + const m = callback; + m.applyBeforeValidation = applyBeforeValidation; + m.global = global2; + m.mutates = mutates; + this.globalMiddleware.push(callback); + } + return this.yargs; + } + addCoerceMiddleware(callback, option) { + const aliases = this.yargs.getAliases(); + this.globalMiddleware = this.globalMiddleware.filter((m) => { + const toCheck = [...aliases[option] || [], option]; + if (!m.option) + return true; + else + return !toCheck.includes(m.option); + }); + callback.option = option; + return this.addMiddleware(callback, true, true, true); + } + getMiddleware() { + return this.globalMiddleware; + } + freeze() { + this.frozens.push([...this.globalMiddleware]); + } + unfreeze() { + const frozen = this.frozens.pop(); + if (frozen !== void 0) + this.globalMiddleware = frozen; + } + reset() { + this.globalMiddleware = this.globalMiddleware.filter((m) => m.global); + } +}; +function commandMiddlewareFactory(commandMiddleware) { + if (!commandMiddleware) + return []; + return commandMiddleware.map((middleware) => { + middleware.applyBeforeValidation = false; + return middleware; + }); +} +function applyMiddleware(argv, yargs, middlewares, beforeValidation) { + return middlewares.reduce((acc, middleware) => { + if (middleware.applyBeforeValidation !== beforeValidation) { + return acc; + } + if (middleware.mutates) { + if (middleware.applied) + return acc; + middleware.applied = true; + } + if (isPromise(acc)) { + return acc.then((initialObj) => Promise.all([initialObj, middleware(initialObj, yargs)])).then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj)); + } else { + const result = middleware(acc, yargs); + return isPromise(result) ? result.then((middlewareObj) => Object.assign(acc, middlewareObj)) : Object.assign(acc, result); + } + }, argv); +} + +// ../testeranto/node_modules/yargs/build/lib/utils/maybe-async-result.js +init_cjs_shim(); +function maybeAsyncResult(getResult, resultHandler, errorHandler = (err) => { + throw err; +}) { + try { + const result = isFunction(getResult) ? getResult() : getResult; + return isPromise(result) ? result.then((result2) => resultHandler(result2)) : resultHandler(result); + } catch (err) { + return errorHandler(err); + } +} +function isFunction(arg) { + return typeof arg === "function"; +} + +// ../testeranto/node_modules/yargs/build/lib/utils/which-module.js +init_cjs_shim(); +function whichModule(exported) { + if (typeof __require === "undefined") + return null; + for (let i = 0, files = Object.keys(__require.cache), mod; i < files.length; i++) { + mod = __require.cache[files[i]]; + if (mod.exports === exported) + return mod; + } + return null; +} + +// ../testeranto/node_modules/yargs/build/lib/command.js +var DEFAULT_MARKER = /(^\*)|(^\$0)/; +var CommandInstance = class { + constructor(usage2, validation2, globalMiddleware, shim3) { + this.requireCache = /* @__PURE__ */ new Set(); + this.handlers = {}; + this.aliasMap = {}; + this.frozens = []; + this.shim = shim3; + this.usage = usage2; + this.globalMiddleware = globalMiddleware; + this.validation = validation2; + } + addDirectory(dir, req, callerFile, opts) { + opts = opts || {}; + if (typeof opts.recurse !== "boolean") + opts.recurse = false; + if (!Array.isArray(opts.extensions)) + opts.extensions = ["js"]; + const parentVisit = typeof opts.visit === "function" ? opts.visit : (o) => o; + opts.visit = (obj, joined, filename) => { + const visited = parentVisit(obj, joined, filename); + if (visited) { + if (this.requireCache.has(joined)) + return visited; + else + this.requireCache.add(joined); + this.addHandler(visited); + } + return visited; + }; + this.shim.requireDirectory({ require: req, filename: callerFile }, dir, opts); + } + addHandler(cmd, description, builder, handler, commandMiddleware, deprecated) { + let aliases = []; + const middlewares = commandMiddlewareFactory(commandMiddleware); + handler = handler || (() => { + }); + if (Array.isArray(cmd)) { + if (isCommandAndAliases(cmd)) { + [cmd, ...aliases] = cmd; + } else { + for (const command2 of cmd) { + this.addHandler(command2); + } + } + } else if (isCommandHandlerDefinition(cmd)) { + let command2 = Array.isArray(cmd.command) || typeof cmd.command === "string" ? cmd.command : this.moduleName(cmd); + if (cmd.aliases) + command2 = [].concat(command2).concat(cmd.aliases); + this.addHandler(command2, this.extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated); + return; + } else if (isCommandBuilderDefinition(builder)) { + this.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated); + return; + } + if (typeof cmd === "string") { + const parsedCommand = parseCommand(cmd); + aliases = aliases.map((alias) => parseCommand(alias).cmd); + let isDefault = false; + const parsedAliases = [parsedCommand.cmd].concat(aliases).filter((c) => { + if (DEFAULT_MARKER.test(c)) { + isDefault = true; + return false; + } + return true; + }); + if (parsedAliases.length === 0 && isDefault) + parsedAliases.push("$0"); + if (isDefault) { + parsedCommand.cmd = parsedAliases[0]; + aliases = parsedAliases.slice(1); + cmd = cmd.replace(DEFAULT_MARKER, parsedCommand.cmd); + } + aliases.forEach((alias) => { + this.aliasMap[alias] = parsedCommand.cmd; + }); + if (description !== false) { + this.usage.command(cmd, description, isDefault, aliases, deprecated); + } + this.handlers[parsedCommand.cmd] = { + original: cmd, + description, + handler, + builder: builder || {}, + middlewares, + deprecated, + demanded: parsedCommand.demanded, + optional: parsedCommand.optional + }; + if (isDefault) + this.defaultCommand = this.handlers[parsedCommand.cmd]; + } + } + getCommandHandlers() { + return this.handlers; + } + getCommands() { + return Object.keys(this.handlers).concat(Object.keys(this.aliasMap)); + } + hasDefaultCommand() { + return !!this.defaultCommand; + } + runCommand(command2, yargs, parsed, commandIndex, helpOnly, helpOrVersionSet) { + const commandHandler = this.handlers[command2] || this.handlers[this.aliasMap[command2]] || this.defaultCommand; + const currentContext = yargs.getInternalMethods().getContext(); + const parentCommands = currentContext.commands.slice(); + const isDefaultCommand = !command2; + if (command2) { + currentContext.commands.push(command2); + currentContext.fullCommands.push(commandHandler.original); + } + const builderResult = this.applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, parsed.aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet); + return isPromise(builderResult) ? builderResult.then((result) => this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, result.innerArgv, currentContext, helpOnly, result.aliases, yargs)) : this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, builderResult.innerArgv, currentContext, helpOnly, builderResult.aliases, yargs); + } + applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet) { + const builder = commandHandler.builder; + let innerYargs = yargs; + if (isCommandBuilderCallback(builder)) { + yargs.getInternalMethods().getUsageInstance().freeze(); + const builderOutput = builder(yargs.getInternalMethods().reset(aliases), helpOrVersionSet); + if (isPromise(builderOutput)) { + return builderOutput.then((output) => { + innerYargs = isYargsInstance(output) ? output : yargs; + return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly); + }); + } + } else if (isCommandBuilderOptionDefinitions(builder)) { + yargs.getInternalMethods().getUsageInstance().freeze(); + innerYargs = yargs.getInternalMethods().reset(aliases); + Object.keys(commandHandler.builder).forEach((key) => { + innerYargs.option(key, builder[key]); + }); + } + return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly); + } + parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly) { + if (isDefaultCommand) + innerYargs.getInternalMethods().getUsageInstance().unfreeze(true); + if (this.shouldUpdateUsage(innerYargs)) { + innerYargs.getInternalMethods().getUsageInstance().usage(this.usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description); + } + const innerArgv = innerYargs.getInternalMethods().runYargsParserAndExecuteCommands(null, void 0, true, commandIndex, helpOnly); + return isPromise(innerArgv) ? innerArgv.then((argv) => ({ + aliases: innerYargs.parsed.aliases, + innerArgv: argv + })) : { + aliases: innerYargs.parsed.aliases, + innerArgv + }; + } + shouldUpdateUsage(yargs) { + return !yargs.getInternalMethods().getUsageInstance().getUsageDisabled() && yargs.getInternalMethods().getUsageInstance().getUsage().length === 0; + } + usageFromParentCommandsCommandHandler(parentCommands, commandHandler) { + const c = DEFAULT_MARKER.test(commandHandler.original) ? commandHandler.original.replace(DEFAULT_MARKER, "").trim() : commandHandler.original; + const pc = parentCommands.filter((c2) => { + return !DEFAULT_MARKER.test(c2); + }); + pc.push(c); + return `$0 ${pc.join(" ")}`; + } + handleValidationAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, aliases, yargs, middlewares, positionalMap) { + if (!yargs.getInternalMethods().getHasOutput()) { + const validation2 = yargs.getInternalMethods().runValidation(aliases, positionalMap, yargs.parsed.error, isDefaultCommand); + innerArgv = maybeAsyncResult(innerArgv, (result) => { + validation2(result); + return result; + }); + } + if (commandHandler.handler && !yargs.getInternalMethods().getHasOutput()) { + yargs.getInternalMethods().setHasOutput(); + const populateDoubleDash = !!yargs.getOptions().configuration["populate--"]; + yargs.getInternalMethods().postProcess(innerArgv, populateDoubleDash, false, false); + innerArgv = applyMiddleware(innerArgv, yargs, middlewares, false); + innerArgv = maybeAsyncResult(innerArgv, (result) => { + const handlerResult = commandHandler.handler(result); + return isPromise(handlerResult) ? handlerResult.then(() => result) : result; + }); + if (!isDefaultCommand) { + yargs.getInternalMethods().getUsageInstance().cacheHelpMessage(); + } + if (isPromise(innerArgv) && !yargs.getInternalMethods().hasParseCallback()) { + innerArgv.catch((error) => { + try { + yargs.getInternalMethods().getUsageInstance().fail(null, error); + } catch (_err) { + } + }); + } + } + if (!isDefaultCommand) { + currentContext.commands.pop(); + currentContext.fullCommands.pop(); + } + return innerArgv; + } + applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, helpOnly, aliases, yargs) { + let positionalMap = {}; + if (helpOnly) + return innerArgv; + if (!yargs.getInternalMethods().getHasOutput()) { + positionalMap = this.populatePositionals(commandHandler, innerArgv, currentContext, yargs); + } + const middlewares = this.globalMiddleware.getMiddleware().slice(0).concat(commandHandler.middlewares); + const maybePromiseArgv = applyMiddleware(innerArgv, yargs, middlewares, true); + return isPromise(maybePromiseArgv) ? maybePromiseArgv.then((resolvedInnerArgv) => this.handleValidationAndGetResult(isDefaultCommand, commandHandler, resolvedInnerArgv, currentContext, aliases, yargs, middlewares, positionalMap)) : this.handleValidationAndGetResult(isDefaultCommand, commandHandler, maybePromiseArgv, currentContext, aliases, yargs, middlewares, positionalMap); + } + populatePositionals(commandHandler, argv, context, yargs) { + argv._ = argv._.slice(context.commands.length); + const demanded = commandHandler.demanded.slice(0); + const optional = commandHandler.optional.slice(0); + const positionalMap = {}; + this.validation.positionalCount(demanded.length, argv._.length); + while (demanded.length) { + const demand = demanded.shift(); + this.populatePositional(demand, argv, positionalMap); + } + while (optional.length) { + const maybe = optional.shift(); + this.populatePositional(maybe, argv, positionalMap); + } + argv._ = context.commands.concat(argv._.map((a) => "" + a)); + this.postProcessPositionals(argv, positionalMap, this.cmdToParseOptions(commandHandler.original), yargs); + return positionalMap; + } + populatePositional(positional, argv, positionalMap) { + const cmd = positional.cmd[0]; + if (positional.variadic) { + positionalMap[cmd] = argv._.splice(0).map(String); + } else { + if (argv._.length) + positionalMap[cmd] = [String(argv._.shift())]; + } + } + cmdToParseOptions(cmdString) { + const parseOptions = { + array: [], + default: {}, + alias: {}, + demand: {} + }; + const parsed = parseCommand(cmdString); + parsed.demanded.forEach((d) => { + const [cmd, ...aliases] = d.cmd; + if (d.variadic) { + parseOptions.array.push(cmd); + parseOptions.default[cmd] = []; + } + parseOptions.alias[cmd] = aliases; + parseOptions.demand[cmd] = true; + }); + parsed.optional.forEach((o) => { + const [cmd, ...aliases] = o.cmd; + if (o.variadic) { + parseOptions.array.push(cmd); + parseOptions.default[cmd] = []; + } + parseOptions.alias[cmd] = aliases; + }); + return parseOptions; + } + postProcessPositionals(argv, positionalMap, parseOptions, yargs) { + const options = Object.assign({}, yargs.getOptions()); + options.default = Object.assign(parseOptions.default, options.default); + for (const key of Object.keys(parseOptions.alias)) { + options.alias[key] = (options.alias[key] || []).concat(parseOptions.alias[key]); + } + options.array = options.array.concat(parseOptions.array); + options.config = {}; + const unparsed = []; + Object.keys(positionalMap).forEach((key) => { + positionalMap[key].map((value) => { + if (options.configuration["unknown-options-as-args"]) + options.key[key] = true; + unparsed.push(`--${key}`); + unparsed.push(value); + }); + }); + if (!unparsed.length) + return; + const config2 = Object.assign({}, options.configuration, { + "populate--": false + }); + const parsed = this.shim.Parser.detailed(unparsed, Object.assign({}, options, { + configuration: config2 + })); + if (parsed.error) { + yargs.getInternalMethods().getUsageInstance().fail(parsed.error.message, parsed.error); + } else { + const positionalKeys = Object.keys(positionalMap); + Object.keys(positionalMap).forEach((key) => { + positionalKeys.push(...parsed.aliases[key]); + }); + Object.keys(parsed.argv).forEach((key) => { + if (positionalKeys.includes(key)) { + if (!positionalMap[key]) + positionalMap[key] = parsed.argv[key]; + if (!this.isInConfigs(yargs, key) && !this.isDefaulted(yargs, key) && Object.prototype.hasOwnProperty.call(argv, key) && Object.prototype.hasOwnProperty.call(parsed.argv, key) && (Array.isArray(argv[key]) || Array.isArray(parsed.argv[key]))) { + argv[key] = [].concat(argv[key], parsed.argv[key]); + } else { + argv[key] = parsed.argv[key]; + } + } + }); + } + } + isDefaulted(yargs, key) { + const { default: defaults } = yargs.getOptions(); + return Object.prototype.hasOwnProperty.call(defaults, key) || Object.prototype.hasOwnProperty.call(defaults, this.shim.Parser.camelCase(key)); + } + isInConfigs(yargs, key) { + const { configObjects } = yargs.getOptions(); + return configObjects.some((c) => Object.prototype.hasOwnProperty.call(c, key)) || configObjects.some((c) => Object.prototype.hasOwnProperty.call(c, this.shim.Parser.camelCase(key))); + } + runDefaultBuilderOn(yargs) { + if (!this.defaultCommand) + return; + if (this.shouldUpdateUsage(yargs)) { + const commandString = DEFAULT_MARKER.test(this.defaultCommand.original) ? this.defaultCommand.original : this.defaultCommand.original.replace(/^[^[\]<>]*/, "$0 "); + yargs.getInternalMethods().getUsageInstance().usage(commandString, this.defaultCommand.description); + } + const builder = this.defaultCommand.builder; + if (isCommandBuilderCallback(builder)) { + return builder(yargs, true); + } else if (!isCommandBuilderDefinition(builder)) { + Object.keys(builder).forEach((key) => { + yargs.option(key, builder[key]); + }); + } + return void 0; + } + moduleName(obj) { + const mod = whichModule(obj); + if (!mod) + throw new Error(`No command name given for module: ${this.shim.inspect(obj)}`); + return this.commandFromFilename(mod.filename); + } + commandFromFilename(filename) { + return this.shim.path.basename(filename, this.shim.path.extname(filename)); + } + extractDesc({ describe, description, desc }) { + for (const test of [describe, description, desc]) { + if (typeof test === "string" || test === false) + return test; + assertNotStrictEqual(test, true, this.shim); + } + return false; + } + freeze() { + this.frozens.push({ + handlers: this.handlers, + aliasMap: this.aliasMap, + defaultCommand: this.defaultCommand + }); + } + unfreeze() { + const frozen = this.frozens.pop(); + assertNotStrictEqual(frozen, void 0, this.shim); + ({ + handlers: this.handlers, + aliasMap: this.aliasMap, + defaultCommand: this.defaultCommand + } = frozen); + } + reset() { + this.handlers = {}; + this.aliasMap = {}; + this.defaultCommand = void 0; + this.requireCache = /* @__PURE__ */ new Set(); + return this; + } +}; +function command(usage2, validation2, globalMiddleware, shim3) { + return new CommandInstance(usage2, validation2, globalMiddleware, shim3); +} +function isCommandBuilderDefinition(builder) { + return typeof builder === "object" && !!builder.builder && typeof builder.handler === "function"; +} +function isCommandAndAliases(cmd) { + return cmd.every((c) => typeof c === "string"); +} +function isCommandBuilderCallback(builder) { + return typeof builder === "function"; +} +function isCommandBuilderOptionDefinitions(builder) { + return typeof builder === "object"; +} +function isCommandHandlerDefinition(cmd) { + return typeof cmd === "object" && !Array.isArray(cmd); +} + +// ../testeranto/node_modules/yargs/build/lib/usage.js +init_cjs_shim(); + +// ../testeranto/node_modules/yargs/build/lib/utils/obj-filter.js +init_cjs_shim(); +function objFilter(original = {}, filter2 = () => true) { + const obj = {}; + objectKeys(original).forEach((key) => { + if (filter2(key, original[key])) { + obj[key] = original[key]; + } + }); + return obj; +} + +// ../testeranto/node_modules/yargs/build/lib/utils/set-blocking.js +init_cjs_shim(); +function setBlocking(blocking) { + if (typeof process === "undefined") + return; + [process.stdout, process.stderr].forEach((_stream) => { + const stream = _stream; + if (stream._handle && stream.isTTY && typeof stream._handle.setBlocking === "function") { + stream._handle.setBlocking(blocking); + } + }); +} + +// ../testeranto/node_modules/yargs/build/lib/usage.js +function isBoolean(fail) { + return typeof fail === "boolean"; +} +function usage(yargs, shim3) { + const __ = shim3.y18n.__; + const self2 = {}; + const fails = []; + self2.failFn = function failFn(f) { + fails.push(f); + }; + let failMessage = null; + let globalFailMessage = null; + let showHelpOnFail = true; + self2.showHelpOnFail = function showHelpOnFailFn(arg1 = true, arg2) { + const [enabled, message] = typeof arg1 === "string" ? [true, arg1] : [arg1, arg2]; + if (yargs.getInternalMethods().isGlobalContext()) { + globalFailMessage = message; + } + failMessage = message; + showHelpOnFail = enabled; + return self2; + }; + let failureOutput = false; + self2.fail = function fail(msg, err) { + const logger = yargs.getInternalMethods().getLoggerInstance(); + if (fails.length) { + for (let i = fails.length - 1; i >= 0; --i) { + const fail2 = fails[i]; + if (isBoolean(fail2)) { + if (err) + throw err; + else if (msg) + throw Error(msg); + } else { + fail2(msg, err, self2); + } + } + } else { + if (yargs.getExitProcess()) + setBlocking(true); + if (!failureOutput) { + failureOutput = true; + if (showHelpOnFail) { + yargs.showHelp("error"); + logger.error(); + } + if (msg || err) + logger.error(msg || err); + const globalOrCommandFailMessage = failMessage || globalFailMessage; + if (globalOrCommandFailMessage) { + if (msg || err) + logger.error(""); + logger.error(globalOrCommandFailMessage); + } + } + err = err || new YError(msg); + if (yargs.getExitProcess()) { + return yargs.exit(1); + } else if (yargs.getInternalMethods().hasParseCallback()) { + return yargs.exit(1, err); + } else { + throw err; + } + } + }; + let usages = []; + let usageDisabled = false; + self2.usage = (msg, description) => { + if (msg === null) { + usageDisabled = true; + usages = []; + return self2; + } + usageDisabled = false; + usages.push([msg, description || ""]); + return self2; + }; + self2.getUsage = () => { + return usages; + }; + self2.getUsageDisabled = () => { + return usageDisabled; + }; + self2.getPositionalGroupName = () => { + return __("Positionals:"); + }; + let examples = []; + self2.example = (cmd, description) => { + examples.push([cmd, description || ""]); + }; + let commands = []; + self2.command = function command2(cmd, description, isDefault, aliases, deprecated = false) { + if (isDefault) { + commands = commands.map((cmdArray) => { + cmdArray[2] = false; + return cmdArray; + }); + } + commands.push([cmd, description || "", isDefault, aliases, deprecated]); + }; + self2.getCommands = () => commands; + let descriptions = {}; + self2.describe = function describe(keyOrKeys, desc) { + if (Array.isArray(keyOrKeys)) { + keyOrKeys.forEach((k) => { + self2.describe(k, desc); + }); + } else if (typeof keyOrKeys === "object") { + Object.keys(keyOrKeys).forEach((k) => { + self2.describe(k, keyOrKeys[k]); + }); + } else { + descriptions[keyOrKeys] = desc; + } + }; + self2.getDescriptions = () => descriptions; + let epilogs = []; + self2.epilog = (msg) => { + epilogs.push(msg); + }; + let wrapSet = false; + let wrap2; + self2.wrap = (cols) => { + wrapSet = true; + wrap2 = cols; + }; + self2.getWrap = () => { + if (shim3.getEnv("YARGS_DISABLE_WRAP")) { + return null; + } + if (!wrapSet) { + wrap2 = windowWidth(); + wrapSet = true; + } + return wrap2; + }; + const deferY18nLookupPrefix = "__yargsString__:"; + self2.deferY18nLookup = (str) => deferY18nLookupPrefix + str; + self2.help = function help() { + if (cachedHelpMessage) + return cachedHelpMessage; + normalizeAliases(); + const base$0 = yargs.customScriptName ? yargs.$0 : shim3.path.basename(yargs.$0); + const demandedOptions = yargs.getDemandedOptions(); + const demandedCommands = yargs.getDemandedCommands(); + const deprecatedOptions = yargs.getDeprecatedOptions(); + const groups = yargs.getGroups(); + const options = yargs.getOptions(); + let keys = []; + keys = keys.concat(Object.keys(descriptions)); + keys = keys.concat(Object.keys(demandedOptions)); + keys = keys.concat(Object.keys(demandedCommands)); + keys = keys.concat(Object.keys(options.default)); + keys = keys.filter(filterHiddenOptions); + keys = Object.keys(keys.reduce((acc, key) => { + if (key !== "_") + acc[key] = true; + return acc; + }, {})); + const theWrap = self2.getWrap(); + const ui2 = shim3.cliui({ + width: theWrap, + wrap: !!theWrap + }); + if (!usageDisabled) { + if (usages.length) { + usages.forEach((usage2) => { + ui2.div({ text: `${usage2[0].replace(/\$0/g, base$0)}` }); + if (usage2[1]) { + ui2.div({ text: `${usage2[1]}`, padding: [1, 0, 0, 0] }); + } + }); + ui2.div(); + } else if (commands.length) { + let u = null; + if (demandedCommands._) { + u = `${base$0} <${__("command")}> +`; + } else { + u = `${base$0} [${__("command")}] +`; + } + ui2.div(`${u}`); + } + } + if (commands.length > 1 || commands.length === 1 && !commands[0][2]) { + ui2.div(__("Commands:")); + const context = yargs.getInternalMethods().getContext(); + const parentCommands = context.commands.length ? `${context.commands.join(" ")} ` : ""; + if (yargs.getInternalMethods().getParserConfiguration()["sort-commands"] === true) { + commands = commands.sort((a, b) => a[0].localeCompare(b[0])); + } + const prefix = base$0 ? `${base$0} ` : ""; + commands.forEach((command2) => { + const commandString = `${prefix}${parentCommands}${command2[0].replace(/^\$0 ?/, "")}`; + ui2.span({ + text: commandString, + padding: [0, 2, 0, 2], + width: maxWidth(commands, theWrap, `${base$0}${parentCommands}`) + 4 + }, { text: command2[1] }); + const hints = []; + if (command2[2]) + hints.push(`[${__("default")}]`); + if (command2[3] && command2[3].length) { + hints.push(`[${__("aliases:")} ${command2[3].join(", ")}]`); + } + if (command2[4]) { + if (typeof command2[4] === "string") { + hints.push(`[${__("deprecated: %s", command2[4])}]`); + } else { + hints.push(`[${__("deprecated")}]`); + } + } + if (hints.length) { + ui2.div({ + text: hints.join(" "), + padding: [0, 0, 0, 2], + align: "right" + }); + } else { + ui2.div(); + } + }); + ui2.div(); + } + const aliasKeys = (Object.keys(options.alias) || []).concat(Object.keys(yargs.parsed.newAliases) || []); + keys = keys.filter((key) => !yargs.parsed.newAliases[key] && aliasKeys.every((alias) => (options.alias[alias] || []).indexOf(key) === -1)); + const defaultGroup = __("Options:"); + if (!groups[defaultGroup]) + groups[defaultGroup] = []; + addUngroupedKeys(keys, options.alias, groups, defaultGroup); + const isLongSwitch = (sw) => /^--/.test(getText2(sw)); + const displayedGroups = Object.keys(groups).filter((groupName) => groups[groupName].length > 0).map((groupName) => { + const normalizedKeys = groups[groupName].filter(filterHiddenOptions).map((key) => { + if (aliasKeys.includes(key)) + return key; + for (let i = 0, aliasKey; (aliasKey = aliasKeys[i]) !== void 0; i++) { + if ((options.alias[aliasKey] || []).includes(key)) + return aliasKey; + } + return key; + }); + return { groupName, normalizedKeys }; + }).filter(({ normalizedKeys }) => normalizedKeys.length > 0).map(({ groupName, normalizedKeys }) => { + const switches = normalizedKeys.reduce((acc, key) => { + acc[key] = [key].concat(options.alias[key] || []).map((sw) => { + if (groupName === self2.getPositionalGroupName()) + return sw; + else { + return (/^[0-9]$/.test(sw) ? options.boolean.includes(key) ? "-" : "--" : sw.length > 1 ? "--" : "-") + sw; + } + }).sort((sw1, sw2) => isLongSwitch(sw1) === isLongSwitch(sw2) ? 0 : isLongSwitch(sw1) ? 1 : -1).join(", "); + return acc; + }, {}); + return { groupName, normalizedKeys, switches }; + }); + const shortSwitchesUsed = displayedGroups.filter(({ groupName }) => groupName !== self2.getPositionalGroupName()).some(({ normalizedKeys, switches }) => !normalizedKeys.every((key) => isLongSwitch(switches[key]))); + if (shortSwitchesUsed) { + displayedGroups.filter(({ groupName }) => groupName !== self2.getPositionalGroupName()).forEach(({ normalizedKeys, switches }) => { + normalizedKeys.forEach((key) => { + if (isLongSwitch(switches[key])) { + switches[key] = addIndentation(switches[key], "-x, ".length); + } + }); + }); + } + displayedGroups.forEach(({ groupName, normalizedKeys, switches }) => { + ui2.div(groupName); + normalizedKeys.forEach((key) => { + const kswitch = switches[key]; + let desc = descriptions[key] || ""; + let type = null; + if (desc.includes(deferY18nLookupPrefix)) + desc = __(desc.substring(deferY18nLookupPrefix.length)); + if (options.boolean.includes(key)) + type = `[${__("boolean")}]`; + if (options.count.includes(key)) + type = `[${__("count")}]`; + if (options.string.includes(key)) + type = `[${__("string")}]`; + if (options.normalize.includes(key)) + type = `[${__("string")}]`; + if (options.array.includes(key)) + type = `[${__("array")}]`; + if (options.number.includes(key)) + type = `[${__("number")}]`; + const deprecatedExtra = (deprecated) => typeof deprecated === "string" ? `[${__("deprecated: %s", deprecated)}]` : `[${__("deprecated")}]`; + const extra = [ + key in deprecatedOptions ? deprecatedExtra(deprecatedOptions[key]) : null, + type, + key in demandedOptions ? `[${__("required")}]` : null, + options.choices && options.choices[key] ? `[${__("choices:")} ${self2.stringifiedValues(options.choices[key])}]` : null, + defaultString(options.default[key], options.defaultDescription[key]) + ].filter(Boolean).join(" "); + ui2.span({ + text: getText2(kswitch), + padding: [0, 2, 0, 2 + getIndentation(kswitch)], + width: maxWidth(switches, theWrap) + 4 + }, desc); + const shouldHideOptionExtras = yargs.getInternalMethods().getUsageConfiguration()["hide-types"] === true; + if (extra && !shouldHideOptionExtras) + ui2.div({ text: extra, padding: [0, 0, 0, 2], align: "right" }); + else + ui2.div(); + }); + ui2.div(); + }); + if (examples.length) { + ui2.div(__("Examples:")); + examples.forEach((example) => { + example[0] = example[0].replace(/\$0/g, base$0); + }); + examples.forEach((example) => { + if (example[1] === "") { + ui2.div({ + text: example[0], + padding: [0, 2, 0, 2] + }); + } else { + ui2.div({ + text: example[0], + padding: [0, 2, 0, 2], + width: maxWidth(examples, theWrap) + 4 + }, { + text: example[1] + }); + } + }); + ui2.div(); + } + if (epilogs.length > 0) { + const e = epilogs.map((epilog) => epilog.replace(/\$0/g, base$0)).join("\n"); + ui2.div(`${e} +`); + } + return ui2.toString().replace(/\s*$/, ""); + }; + function maxWidth(table, theWrap, modifier) { + let width = 0; + if (!Array.isArray(table)) { + table = Object.values(table).map((v) => [v]); + } + table.forEach((v) => { + width = Math.max(shim3.stringWidth(modifier ? `${modifier} ${getText2(v[0])}` : getText2(v[0])) + getIndentation(v[0]), width); + }); + if (theWrap) + width = Math.min(width, parseInt((theWrap * 0.5).toString(), 10)); + return width; + } + function normalizeAliases() { + const demandedOptions = yargs.getDemandedOptions(); + const options = yargs.getOptions(); + (Object.keys(options.alias) || []).forEach((key) => { + options.alias[key].forEach((alias) => { + if (descriptions[alias]) + self2.describe(key, descriptions[alias]); + if (alias in demandedOptions) + yargs.demandOption(key, demandedOptions[alias]); + if (options.boolean.includes(alias)) + yargs.boolean(key); + if (options.count.includes(alias)) + yargs.count(key); + if (options.string.includes(alias)) + yargs.string(key); + if (options.normalize.includes(alias)) + yargs.normalize(key); + if (options.array.includes(alias)) + yargs.array(key); + if (options.number.includes(alias)) + yargs.number(key); + }); + }); + } + let cachedHelpMessage; + self2.cacheHelpMessage = function() { + cachedHelpMessage = this.help(); + }; + self2.clearCachedHelpMessage = function() { + cachedHelpMessage = void 0; + }; + self2.hasCachedHelpMessage = function() { + return !!cachedHelpMessage; + }; + function addUngroupedKeys(keys, aliases, groups, defaultGroup) { + let groupedKeys = []; + let toCheck = null; + Object.keys(groups).forEach((group) => { + groupedKeys = groupedKeys.concat(groups[group]); + }); + keys.forEach((key) => { + toCheck = [key].concat(aliases[key]); + if (!toCheck.some((k) => groupedKeys.indexOf(k) !== -1)) { + groups[defaultGroup].push(key); + } + }); + return groupedKeys; + } + function filterHiddenOptions(key) { + return yargs.getOptions().hiddenOptions.indexOf(key) < 0 || yargs.parsed.argv[yargs.getOptions().showHiddenOpt]; + } + self2.showHelp = (level) => { + const logger = yargs.getInternalMethods().getLoggerInstance(); + if (!level) + level = "error"; + const emit = typeof level === "function" ? level : logger[level]; + emit(self2.help()); + }; + self2.functionDescription = (fn) => { + const description = fn.name ? shim3.Parser.decamelize(fn.name, "-") : __("generated-value"); + return ["(", description, ")"].join(""); + }; + self2.stringifiedValues = function stringifiedValues(values, separator) { + let string = ""; + const sep = separator || ", "; + const array = [].concat(values); + if (!values || !array.length) + return string; + array.forEach((value) => { + if (string.length) + string += sep; + string += JSON.stringify(value); + }); + return string; + }; + function defaultString(value, defaultDescription) { + let string = `[${__("default:")} `; + if (value === void 0 && !defaultDescription) + return null; + if (defaultDescription) { + string += defaultDescription; + } else { + switch (typeof value) { + case "string": + string += `"${value}"`; + break; + case "object": + string += JSON.stringify(value); + break; + default: + string += value; + } + } + return `${string}]`; + } + function windowWidth() { + const maxWidth2 = 80; + if (shim3.process.stdColumns) { + return Math.min(maxWidth2, shim3.process.stdColumns); + } else { + return maxWidth2; + } + } + let version2 = null; + self2.version = (ver) => { + version2 = ver; + }; + self2.showVersion = (level) => { + const logger = yargs.getInternalMethods().getLoggerInstance(); + if (!level) + level = "error"; + const emit = typeof level === "function" ? level : logger[level]; + emit(version2); + }; + self2.reset = function reset(localLookup) { + failMessage = null; + failureOutput = false; + usages = []; + usageDisabled = false; + epilogs = []; + examples = []; + commands = []; + descriptions = objFilter(descriptions, (k) => !localLookup[k]); + return self2; + }; + const frozens = []; + self2.freeze = function freeze() { + frozens.push({ + failMessage, + failureOutput, + usages, + usageDisabled, + epilogs, + examples, + commands, + descriptions + }); + }; + self2.unfreeze = function unfreeze(defaultCommand = false) { + const frozen = frozens.pop(); + if (!frozen) + return; + if (defaultCommand) { + descriptions = { ...frozen.descriptions, ...descriptions }; + commands = [...frozen.commands, ...commands]; + usages = [...frozen.usages, ...usages]; + examples = [...frozen.examples, ...examples]; + epilogs = [...frozen.epilogs, ...epilogs]; + } else { + ({ + failMessage, + failureOutput, + usages, + usageDisabled, + epilogs, + examples, + commands, + descriptions + } = frozen); + } + }; + return self2; +} +function isIndentedText(text) { + return typeof text === "object"; +} +function addIndentation(text, indent) { + return isIndentedText(text) ? { text: text.text, indentation: text.indentation + indent } : { text, indentation: indent }; +} +function getIndentation(text) { + return isIndentedText(text) ? text.indentation : 0; +} +function getText2(text) { + return isIndentedText(text) ? text.text : text; +} + +// ../testeranto/node_modules/yargs/build/lib/completion.js +init_cjs_shim(); + +// ../testeranto/node_modules/yargs/build/lib/completion-templates.js +init_cjs_shim(); +var completionShTemplate = `###-begin-{{app_name}}-completions-### +# +# yargs command completion script +# +# Installation: {{app_path}} {{completion_command}} >> ~/.bashrc +# or {{app_path}} {{completion_command}} >> ~/.bash_profile on OSX. +# +_{{app_name}}_yargs_completions() +{ + local cur_word args type_list + + cur_word="\${COMP_WORDS[COMP_CWORD]}" + args=("\${COMP_WORDS[@]}") + + # ask yargs to generate completions. + type_list=$({{app_path}} --get-yargs-completions "\${args[@]}") + + COMPREPLY=( $(compgen -W "\${type_list}" -- \${cur_word}) ) + + # if no match was found, fall back to filename completion + if [ \${#COMPREPLY[@]} -eq 0 ]; then + COMPREPLY=() + fi + + return 0 +} +complete -o bashdefault -o default -F _{{app_name}}_yargs_completions {{app_name}} +###-end-{{app_name}}-completions-### +`; +var completionZshTemplate = `#compdef {{app_name}} +###-begin-{{app_name}}-completions-### +# +# yargs command completion script +# +# Installation: {{app_path}} {{completion_command}} >> ~/.zshrc +# or {{app_path}} {{completion_command}} >> ~/.zprofile on OSX. +# +_{{app_name}}_yargs_completions() +{ + local reply + local si=$IFS + IFS=$' +' reply=($(COMP_CWORD="$((CURRENT-1))" COMP_LINE="$BUFFER" COMP_POINT="$CURSOR" {{app_path}} --get-yargs-completions "\${words[@]}")) + IFS=$si + _describe 'values' reply +} +compdef _{{app_name}}_yargs_completions {{app_name}} +###-end-{{app_name}}-completions-### +`; + +// ../testeranto/node_modules/yargs/build/lib/completion.js +var Completion = class { + constructor(yargs, usage2, command2, shim3) { + var _a2, _b2, _c2; + this.yargs = yargs; + this.usage = usage2; + this.command = command2; + this.shim = shim3; + this.completionKey = "get-yargs-completions"; + this.aliases = null; + this.customCompletionFunction = null; + this.indexAfterLastReset = 0; + this.zshShell = (_c2 = ((_a2 = this.shim.getEnv("SHELL")) === null || _a2 === void 0 ? void 0 : _a2.includes("zsh")) || ((_b2 = this.shim.getEnv("ZSH_NAME")) === null || _b2 === void 0 ? void 0 : _b2.includes("zsh"))) !== null && _c2 !== void 0 ? _c2 : false; + } + defaultCompletion(args, argv, current, done) { + const handlers = this.command.getCommandHandlers(); + for (let i = 0, ii = args.length; i < ii; ++i) { + if (handlers[args[i]] && handlers[args[i]].builder) { + const builder = handlers[args[i]].builder; + if (isCommandBuilderCallback(builder)) { + this.indexAfterLastReset = i + 1; + const y = this.yargs.getInternalMethods().reset(); + builder(y, true); + return y.argv; + } + } + } + const completions = []; + this.commandCompletions(completions, args, current); + this.optionCompletions(completions, args, argv, current); + this.choicesFromOptionsCompletions(completions, args, argv, current); + this.choicesFromPositionalsCompletions(completions, args, argv, current); + done(null, completions); + } + commandCompletions(completions, args, current) { + const parentCommands = this.yargs.getInternalMethods().getContext().commands; + if (!current.match(/^-/) && parentCommands[parentCommands.length - 1] !== current && !this.previousArgHasChoices(args)) { + this.usage.getCommands().forEach((usageCommand) => { + const commandName = parseCommand(usageCommand[0]).cmd; + if (args.indexOf(commandName) === -1) { + if (!this.zshShell) { + completions.push(commandName); + } else { + const desc = usageCommand[1] || ""; + completions.push(commandName.replace(/:/g, "\\:") + ":" + desc); + } + } + }); + } + } + optionCompletions(completions, args, argv, current) { + if ((current.match(/^-/) || current === "" && completions.length === 0) && !this.previousArgHasChoices(args)) { + const options = this.yargs.getOptions(); + const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || []; + Object.keys(options.key).forEach((key) => { + const negable = !!options.configuration["boolean-negation"] && options.boolean.includes(key); + const isPositionalKey = positionalKeys.includes(key); + if (!isPositionalKey && !options.hiddenOptions.includes(key) && !this.argsContainKey(args, key, negable)) { + this.completeOptionKey(key, completions, current, negable && !!options.default[key]); + } + }); + } + } + choicesFromOptionsCompletions(completions, args, argv, current) { + if (this.previousArgHasChoices(args)) { + const choices = this.getPreviousArgChoices(args); + if (choices && choices.length > 0) { + completions.push(...choices.map((c) => c.replace(/:/g, "\\:"))); + } + } + } + choicesFromPositionalsCompletions(completions, args, argv, current) { + if (current === "" && completions.length > 0 && this.previousArgHasChoices(args)) { + return; + } + const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || []; + const offset = Math.max(this.indexAfterLastReset, this.yargs.getInternalMethods().getContext().commands.length + 1); + const positionalKey = positionalKeys[argv._.length - offset - 1]; + if (!positionalKey) { + return; + } + const choices = this.yargs.getOptions().choices[positionalKey] || []; + for (const choice of choices) { + if (choice.startsWith(current)) { + completions.push(choice.replace(/:/g, "\\:")); + } + } + } + getPreviousArgChoices(args) { + if (args.length < 1) + return; + let previousArg = args[args.length - 1]; + let filter2 = ""; + if (!previousArg.startsWith("-") && args.length > 1) { + filter2 = previousArg; + previousArg = args[args.length - 2]; + } + if (!previousArg.startsWith("-")) + return; + const previousArgKey = previousArg.replace(/^-+/, ""); + const options = this.yargs.getOptions(); + const possibleAliases = [ + previousArgKey, + ...this.yargs.getAliases()[previousArgKey] || [] + ]; + let choices; + for (const possibleAlias of possibleAliases) { + if (Object.prototype.hasOwnProperty.call(options.key, possibleAlias) && Array.isArray(options.choices[possibleAlias])) { + choices = options.choices[possibleAlias]; + break; + } + } + if (choices) { + return choices.filter((choice) => !filter2 || choice.startsWith(filter2)); + } + } + previousArgHasChoices(args) { + const choices = this.getPreviousArgChoices(args); + return choices !== void 0 && choices.length > 0; + } + argsContainKey(args, key, negable) { + const argsContains = (s) => args.indexOf((/^[^0-9]$/.test(s) ? "-" : "--") + s) !== -1; + if (argsContains(key)) + return true; + if (negable && argsContains(`no-${key}`)) + return true; + if (this.aliases) { + for (const alias of this.aliases[key]) { + if (argsContains(alias)) + return true; + } + } + return false; + } + completeOptionKey(key, completions, current, negable) { + var _a2, _b2, _c2, _d; + let keyWithDesc = key; + if (this.zshShell) { + const descs = this.usage.getDescriptions(); + const aliasKey = (_b2 = (_a2 = this === null || this === void 0 ? void 0 : this.aliases) === null || _a2 === void 0 ? void 0 : _a2[key]) === null || _b2 === void 0 ? void 0 : _b2.find((alias) => { + const desc2 = descs[alias]; + return typeof desc2 === "string" && desc2.length > 0; + }); + const descFromAlias = aliasKey ? descs[aliasKey] : void 0; + const desc = (_d = (_c2 = descs[key]) !== null && _c2 !== void 0 ? _c2 : descFromAlias) !== null && _d !== void 0 ? _d : ""; + keyWithDesc = `${key.replace(/:/g, "\\:")}:${desc.replace("__yargsString__:", "").replace(/(\r\n|\n|\r)/gm, " ")}`; + } + const startsByTwoDashes = (s) => /^--/.test(s); + const isShortOption = (s) => /^[^0-9]$/.test(s); + const dashes = !startsByTwoDashes(current) && isShortOption(key) ? "-" : "--"; + completions.push(dashes + keyWithDesc); + if (negable) { + completions.push(dashes + "no-" + keyWithDesc); + } + } + customCompletion(args, argv, current, done) { + assertNotStrictEqual(this.customCompletionFunction, null, this.shim); + if (isSyncCompletionFunction(this.customCompletionFunction)) { + const result = this.customCompletionFunction(current, argv); + if (isPromise(result)) { + return result.then((list) => { + this.shim.process.nextTick(() => { + done(null, list); + }); + }).catch((err) => { + this.shim.process.nextTick(() => { + done(err, void 0); + }); + }); + } + return done(null, result); + } else if (isFallbackCompletionFunction(this.customCompletionFunction)) { + return this.customCompletionFunction(current, argv, (onCompleted = done) => this.defaultCompletion(args, argv, current, onCompleted), (completions) => { + done(null, completions); + }); + } else { + return this.customCompletionFunction(current, argv, (completions) => { + done(null, completions); + }); + } + } + getCompletion(args, done) { + const current = args.length ? args[args.length - 1] : ""; + const argv = this.yargs.parse(args, true); + const completionFunction = this.customCompletionFunction ? (argv2) => this.customCompletion(args, argv2, current, done) : (argv2) => this.defaultCompletion(args, argv2, current, done); + return isPromise(argv) ? argv.then(completionFunction) : completionFunction(argv); + } + generateCompletionScript($0, cmd) { + let script = this.zshShell ? completionZshTemplate : completionShTemplate; + const name = this.shim.path.basename($0); + if ($0.match(/\.js$/)) + $0 = `./${$0}`; + script = script.replace(/{{app_name}}/g, name); + script = script.replace(/{{completion_command}}/g, cmd); + return script.replace(/{{app_path}}/g, $0); + } + registerFunction(fn) { + this.customCompletionFunction = fn; + } + setParsed(parsed) { + this.aliases = parsed.aliases; + } +}; +function completion(yargs, usage2, command2, shim3) { + return new Completion(yargs, usage2, command2, shim3); +} +function isSyncCompletionFunction(completionFunction) { + return completionFunction.length < 3; +} +function isFallbackCompletionFunction(completionFunction) { + return completionFunction.length > 3; +} + +// ../testeranto/node_modules/yargs/build/lib/validation.js +init_cjs_shim(); + +// ../testeranto/node_modules/yargs/build/lib/utils/levenshtein.js +init_cjs_shim(); +function levenshtein(a, b) { + if (a.length === 0) + return b.length; + if (b.length === 0) + return a.length; + const matrix = []; + let i; + for (i = 0; i <= b.length; i++) { + matrix[i] = [i]; + } + let j; + for (j = 0; j <= a.length; j++) { + matrix[0][j] = j; + } + for (i = 1; i <= b.length; i++) { + for (j = 1; j <= a.length; j++) { + if (b.charAt(i - 1) === a.charAt(j - 1)) { + matrix[i][j] = matrix[i - 1][j - 1]; + } else { + if (i > 1 && j > 1 && b.charAt(i - 2) === a.charAt(j - 1) && b.charAt(i - 1) === a.charAt(j - 2)) { + matrix[i][j] = matrix[i - 2][j - 2] + 1; + } else { + matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1)); + } + } + } + } + return matrix[b.length][a.length]; +} + +// ../testeranto/node_modules/yargs/build/lib/validation.js +var specialKeys = ["$0", "--", "_"]; +function validation(yargs, usage2, shim3) { + const __ = shim3.y18n.__; + const __n = shim3.y18n.__n; + const self2 = {}; + self2.nonOptionCount = function nonOptionCount(argv) { + const demandedCommands = yargs.getDemandedCommands(); + const positionalCount = argv._.length + (argv["--"] ? argv["--"].length : 0); + const _s = positionalCount - yargs.getInternalMethods().getContext().commands.length; + if (demandedCommands._ && (_s < demandedCommands._.min || _s > demandedCommands._.max)) { + if (_s < demandedCommands._.min) { + if (demandedCommands._.minMsg !== void 0) { + usage2.fail(demandedCommands._.minMsg ? demandedCommands._.minMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.min.toString()) : null); + } else { + usage2.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", _s, _s.toString(), demandedCommands._.min.toString())); + } + } else if (_s > demandedCommands._.max) { + if (demandedCommands._.maxMsg !== void 0) { + usage2.fail(demandedCommands._.maxMsg ? demandedCommands._.maxMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.max.toString()) : null); + } else { + usage2.fail(__n("Too many non-option arguments: got %s, maximum of %s", "Too many non-option arguments: got %s, maximum of %s", _s, _s.toString(), demandedCommands._.max.toString())); + } + } + } + }; + self2.positionalCount = function positionalCount(required, observed) { + if (observed < required) { + usage2.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", observed, observed + "", required + "")); + } + }; + self2.requiredArguments = function requiredArguments(argv, demandedOptions) { + let missing = null; + for (const key of Object.keys(demandedOptions)) { + if (!Object.prototype.hasOwnProperty.call(argv, key) || typeof argv[key] === "undefined") { + missing = missing || {}; + missing[key] = demandedOptions[key]; + } + } + if (missing) { + const customMsgs = []; + for (const key of Object.keys(missing)) { + const msg = missing[key]; + if (msg && customMsgs.indexOf(msg) < 0) { + customMsgs.push(msg); + } + } + const customMsg = customMsgs.length ? ` +${customMsgs.join("\n")}` : ""; + usage2.fail(__n("Missing required argument: %s", "Missing required arguments: %s", Object.keys(missing).length, Object.keys(missing).join(", ") + customMsg)); + } + }; + self2.unknownArguments = function unknownArguments(argv, aliases, positionalMap, isDefaultCommand, checkPositionals = true) { + var _a2; + const commandKeys = yargs.getInternalMethods().getCommandInstance().getCommands(); + const unknown = []; + const currentContext = yargs.getInternalMethods().getContext(); + Object.keys(argv).forEach((key) => { + if (!specialKeys.includes(key) && !Object.prototype.hasOwnProperty.call(positionalMap, key) && !Object.prototype.hasOwnProperty.call(yargs.getInternalMethods().getParseContext(), key) && !self2.isValidAndSomeAliasIsNotNew(key, aliases)) { + unknown.push(key); + } + }); + if (checkPositionals && (currentContext.commands.length > 0 || commandKeys.length > 0 || isDefaultCommand)) { + argv._.slice(currentContext.commands.length).forEach((key) => { + if (!commandKeys.includes("" + key)) { + unknown.push("" + key); + } + }); + } + if (checkPositionals) { + const demandedCommands = yargs.getDemandedCommands(); + const maxNonOptDemanded = ((_a2 = demandedCommands._) === null || _a2 === void 0 ? void 0 : _a2.max) || 0; + const expected = currentContext.commands.length + maxNonOptDemanded; + if (expected < argv._.length) { + argv._.slice(expected).forEach((key) => { + key = String(key); + if (!currentContext.commands.includes(key) && !unknown.includes(key)) { + unknown.push(key); + } + }); + } + } + if (unknown.length) { + usage2.fail(__n("Unknown argument: %s", "Unknown arguments: %s", unknown.length, unknown.map((s) => s.trim() ? s : `"${s}"`).join(", "))); + } + }; + self2.unknownCommands = function unknownCommands(argv) { + const commandKeys = yargs.getInternalMethods().getCommandInstance().getCommands(); + const unknown = []; + const currentContext = yargs.getInternalMethods().getContext(); + if (currentContext.commands.length > 0 || commandKeys.length > 0) { + argv._.slice(currentContext.commands.length).forEach((key) => { + if (!commandKeys.includes("" + key)) { + unknown.push("" + key); + } + }); + } + if (unknown.length > 0) { + usage2.fail(__n("Unknown command: %s", "Unknown commands: %s", unknown.length, unknown.join(", "))); + return true; + } else { + return false; + } + }; + self2.isValidAndSomeAliasIsNotNew = function isValidAndSomeAliasIsNotNew(key, aliases) { + if (!Object.prototype.hasOwnProperty.call(aliases, key)) { + return false; + } + const newAliases = yargs.parsed.newAliases; + return [key, ...aliases[key]].some((a) => !Object.prototype.hasOwnProperty.call(newAliases, a) || !newAliases[key]); + }; + self2.limitedChoices = function limitedChoices(argv) { + const options = yargs.getOptions(); + const invalid = {}; + if (!Object.keys(options.choices).length) + return; + Object.keys(argv).forEach((key) => { + if (specialKeys.indexOf(key) === -1 && Object.prototype.hasOwnProperty.call(options.choices, key)) { + [].concat(argv[key]).forEach((value) => { + if (options.choices[key].indexOf(value) === -1 && value !== void 0) { + invalid[key] = (invalid[key] || []).concat(value); + } + }); + } + }); + const invalidKeys = Object.keys(invalid); + if (!invalidKeys.length) + return; + let msg = __("Invalid values:"); + invalidKeys.forEach((key) => { + msg += ` + ${__("Argument: %s, Given: %s, Choices: %s", key, usage2.stringifiedValues(invalid[key]), usage2.stringifiedValues(options.choices[key]))}`; + }); + usage2.fail(msg); + }; + let implied = {}; + self2.implies = function implies(key, value) { + argsert(" [array|number|string]", [key, value], arguments.length); + if (typeof key === "object") { + Object.keys(key).forEach((k) => { + self2.implies(k, key[k]); + }); + } else { + yargs.global(key); + if (!implied[key]) { + implied[key] = []; + } + if (Array.isArray(value)) { + value.forEach((i) => self2.implies(key, i)); + } else { + assertNotStrictEqual(value, void 0, shim3); + implied[key].push(value); + } + } + }; + self2.getImplied = function getImplied() { + return implied; + }; + function keyExists(argv, val) { + const num = Number(val); + val = isNaN(num) ? val : num; + if (typeof val === "number") { + val = argv._.length >= val; + } else if (val.match(/^--no-.+/)) { + val = val.match(/^--no-(.+)/)[1]; + val = !Object.prototype.hasOwnProperty.call(argv, val); + } else { + val = Object.prototype.hasOwnProperty.call(argv, val); + } + return val; + } + self2.implications = function implications(argv) { + const implyFail = []; + Object.keys(implied).forEach((key) => { + const origKey = key; + (implied[key] || []).forEach((value) => { + let key2 = origKey; + const origValue = value; + key2 = keyExists(argv, key2); + value = keyExists(argv, value); + if (key2 && !value) { + implyFail.push(` ${origKey} -> ${origValue}`); + } + }); + }); + if (implyFail.length) { + let msg = `${__("Implications failed:")} +`; + implyFail.forEach((value) => { + msg += value; + }); + usage2.fail(msg); + } + }; + let conflicting = {}; + self2.conflicts = function conflicts(key, value) { + argsert(" [array|string]", [key, value], arguments.length); + if (typeof key === "object") { + Object.keys(key).forEach((k) => { + self2.conflicts(k, key[k]); + }); + } else { + yargs.global(key); + if (!conflicting[key]) { + conflicting[key] = []; + } + if (Array.isArray(value)) { + value.forEach((i) => self2.conflicts(key, i)); + } else { + conflicting[key].push(value); + } + } + }; + self2.getConflicting = () => conflicting; + self2.conflicting = function conflictingFn(argv) { + Object.keys(argv).forEach((key) => { + if (conflicting[key]) { + conflicting[key].forEach((value) => { + if (value && argv[key] !== void 0 && argv[value] !== void 0) { + usage2.fail(__("Arguments %s and %s are mutually exclusive", key, value)); + } + }); + } + }); + if (yargs.getInternalMethods().getParserConfiguration()["strip-dashed"]) { + Object.keys(conflicting).forEach((key) => { + conflicting[key].forEach((value) => { + if (value && argv[shim3.Parser.camelCase(key)] !== void 0 && argv[shim3.Parser.camelCase(value)] !== void 0) { + usage2.fail(__("Arguments %s and %s are mutually exclusive", key, value)); + } + }); + }); + } + }; + self2.recommendCommands = function recommendCommands(cmd, potentialCommands) { + const threshold = 3; + potentialCommands = potentialCommands.sort((a, b) => b.length - a.length); + let recommended = null; + let bestDistance = Infinity; + for (let i = 0, candidate; (candidate = potentialCommands[i]) !== void 0; i++) { + const d = levenshtein(cmd, candidate); + if (d <= threshold && d < bestDistance) { + bestDistance = d; + recommended = candidate; + } + } + if (recommended) + usage2.fail(__("Did you mean %s?", recommended)); + }; + self2.reset = function reset(localLookup) { + implied = objFilter(implied, (k) => !localLookup[k]); + conflicting = objFilter(conflicting, (k) => !localLookup[k]); + return self2; + }; + const frozens = []; + self2.freeze = function freeze() { + frozens.push({ + implied, + conflicting + }); + }; + self2.unfreeze = function unfreeze() { + const frozen = frozens.pop(); + assertNotStrictEqual(frozen, void 0, shim3); + ({ implied, conflicting } = frozen); + }; + return self2; +} + +// ../testeranto/node_modules/yargs/build/lib/utils/apply-extends.js +init_cjs_shim(); +var previouslyVisitedConfigs = []; +var shim2; +function applyExtends(config2, cwd, mergeExtends, _shim) { + shim2 = _shim; + let defaultConfig = {}; + if (Object.prototype.hasOwnProperty.call(config2, "extends")) { + if (typeof config2.extends !== "string") + return defaultConfig; + const isPath = /\.json|\..*rc$/.test(config2.extends); + let pathToDefault = null; + if (!isPath) { + try { + pathToDefault = __require.resolve(config2.extends); + } catch (_err) { + return config2; + } + } else { + pathToDefault = getPathToDefaultConfig(cwd, config2.extends); + } + checkForCircularExtends(pathToDefault); + previouslyVisitedConfigs.push(pathToDefault); + defaultConfig = isPath ? JSON.parse(shim2.readFileSync(pathToDefault, "utf8")) : __require(config2.extends); + delete config2.extends; + defaultConfig = applyExtends(defaultConfig, shim2.path.dirname(pathToDefault), mergeExtends, shim2); + } + previouslyVisitedConfigs = []; + return mergeExtends ? mergeDeep(defaultConfig, config2) : Object.assign({}, defaultConfig, config2); +} +function checkForCircularExtends(cfgPath) { + if (previouslyVisitedConfigs.indexOf(cfgPath) > -1) { + throw new YError(`Circular extended configurations: '${cfgPath}'.`); + } +} +function getPathToDefaultConfig(cwd, pathToExtend) { + return shim2.path.resolve(cwd, pathToExtend); +} +function mergeDeep(config1, config2) { + const target = {}; + function isObject(obj) { + return obj && typeof obj === "object" && !Array.isArray(obj); + } + Object.assign(target, config1); + for (const key of Object.keys(config2)) { + if (isObject(config2[key]) && isObject(target[key])) { + target[key] = mergeDeep(config1[key], config2[key]); + } else { + target[key] = config2[key]; + } + } + return target; +} + +// ../testeranto/node_modules/yargs/build/lib/yargs-factory.js +var __classPrivateFieldSet2 = function(receiver, state, value, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; +}; +var __classPrivateFieldGet2 = function(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var _YargsInstance_command; +var _YargsInstance_cwd; +var _YargsInstance_context; +var _YargsInstance_completion; +var _YargsInstance_completionCommand; +var _YargsInstance_defaultShowHiddenOpt; +var _YargsInstance_exitError; +var _YargsInstance_detectLocale; +var _YargsInstance_emittedWarnings; +var _YargsInstance_exitProcess; +var _YargsInstance_frozens; +var _YargsInstance_globalMiddleware; +var _YargsInstance_groups; +var _YargsInstance_hasOutput; +var _YargsInstance_helpOpt; +var _YargsInstance_isGlobalContext; +var _YargsInstance_logger; +var _YargsInstance_output; +var _YargsInstance_options; +var _YargsInstance_parentRequire; +var _YargsInstance_parserConfig; +var _YargsInstance_parseFn; +var _YargsInstance_parseContext; +var _YargsInstance_pkgs; +var _YargsInstance_preservedGroups; +var _YargsInstance_processArgs; +var _YargsInstance_recommendCommands; +var _YargsInstance_shim; +var _YargsInstance_strict; +var _YargsInstance_strictCommands; +var _YargsInstance_strictOptions; +var _YargsInstance_usage; +var _YargsInstance_usageConfig; +var _YargsInstance_versionOpt; +var _YargsInstance_validation; +function YargsFactory(_shim) { + return (processArgs = [], cwd = _shim.process.cwd(), parentRequire) => { + const yargs = new YargsInstance(processArgs, cwd, parentRequire, _shim); + Object.defineProperty(yargs, "argv", { + get: () => { + return yargs.parse(); + }, + enumerable: true + }); + yargs.help(); + yargs.version(); + return yargs; + }; +} +var kCopyDoubleDash = Symbol("copyDoubleDash"); +var kCreateLogger = Symbol("copyDoubleDash"); +var kDeleteFromParserHintObject = Symbol("deleteFromParserHintObject"); +var kEmitWarning = Symbol("emitWarning"); +var kFreeze = Symbol("freeze"); +var kGetDollarZero = Symbol("getDollarZero"); +var kGetParserConfiguration = Symbol("getParserConfiguration"); +var kGetUsageConfiguration = Symbol("getUsageConfiguration"); +var kGuessLocale = Symbol("guessLocale"); +var kGuessVersion = Symbol("guessVersion"); +var kParsePositionalNumbers = Symbol("parsePositionalNumbers"); +var kPkgUp = Symbol("pkgUp"); +var kPopulateParserHintArray = Symbol("populateParserHintArray"); +var kPopulateParserHintSingleValueDictionary = Symbol("populateParserHintSingleValueDictionary"); +var kPopulateParserHintArrayDictionary = Symbol("populateParserHintArrayDictionary"); +var kPopulateParserHintDictionary = Symbol("populateParserHintDictionary"); +var kSanitizeKey = Symbol("sanitizeKey"); +var kSetKey = Symbol("setKey"); +var kUnfreeze = Symbol("unfreeze"); +var kValidateAsync = Symbol("validateAsync"); +var kGetCommandInstance = Symbol("getCommandInstance"); +var kGetContext = Symbol("getContext"); +var kGetHasOutput = Symbol("getHasOutput"); +var kGetLoggerInstance = Symbol("getLoggerInstance"); +var kGetParseContext = Symbol("getParseContext"); +var kGetUsageInstance = Symbol("getUsageInstance"); +var kGetValidationInstance = Symbol("getValidationInstance"); +var kHasParseCallback = Symbol("hasParseCallback"); +var kIsGlobalContext = Symbol("isGlobalContext"); +var kPostProcess = Symbol("postProcess"); +var kRebase = Symbol("rebase"); +var kReset = Symbol("reset"); +var kRunYargsParserAndExecuteCommands = Symbol("runYargsParserAndExecuteCommands"); +var kRunValidation = Symbol("runValidation"); +var kSetHasOutput = Symbol("setHasOutput"); +var kTrackManuallySetKeys = Symbol("kTrackManuallySetKeys"); +var YargsInstance = class { + constructor(processArgs = [], cwd, parentRequire, shim3) { + this.customScriptName = false; + this.parsed = false; + _YargsInstance_command.set(this, void 0); + _YargsInstance_cwd.set(this, void 0); + _YargsInstance_context.set(this, { commands: [], fullCommands: [] }); + _YargsInstance_completion.set(this, null); + _YargsInstance_completionCommand.set(this, null); + _YargsInstance_defaultShowHiddenOpt.set(this, "show-hidden"); + _YargsInstance_exitError.set(this, null); + _YargsInstance_detectLocale.set(this, true); + _YargsInstance_emittedWarnings.set(this, {}); + _YargsInstance_exitProcess.set(this, true); + _YargsInstance_frozens.set(this, []); + _YargsInstance_globalMiddleware.set(this, void 0); + _YargsInstance_groups.set(this, {}); + _YargsInstance_hasOutput.set(this, false); + _YargsInstance_helpOpt.set(this, null); + _YargsInstance_isGlobalContext.set(this, true); + _YargsInstance_logger.set(this, void 0); + _YargsInstance_output.set(this, ""); + _YargsInstance_options.set(this, void 0); + _YargsInstance_parentRequire.set(this, void 0); + _YargsInstance_parserConfig.set(this, {}); + _YargsInstance_parseFn.set(this, null); + _YargsInstance_parseContext.set(this, null); + _YargsInstance_pkgs.set(this, {}); + _YargsInstance_preservedGroups.set(this, {}); + _YargsInstance_processArgs.set(this, void 0); + _YargsInstance_recommendCommands.set(this, false); + _YargsInstance_shim.set(this, void 0); + _YargsInstance_strict.set(this, false); + _YargsInstance_strictCommands.set(this, false); + _YargsInstance_strictOptions.set(this, false); + _YargsInstance_usage.set(this, void 0); + _YargsInstance_usageConfig.set(this, {}); + _YargsInstance_versionOpt.set(this, null); + _YargsInstance_validation.set(this, void 0); + __classPrivateFieldSet2(this, _YargsInstance_shim, shim3, "f"); + __classPrivateFieldSet2(this, _YargsInstance_processArgs, processArgs, "f"); + __classPrivateFieldSet2(this, _YargsInstance_cwd, cwd, "f"); + __classPrivateFieldSet2(this, _YargsInstance_parentRequire, parentRequire, "f"); + __classPrivateFieldSet2(this, _YargsInstance_globalMiddleware, new GlobalMiddleware(this), "f"); + this.$0 = this[kGetDollarZero](); + this[kReset](); + __classPrivateFieldSet2(this, _YargsInstance_command, __classPrivateFieldGet2(this, _YargsInstance_command, "f"), "f"); + __classPrivateFieldSet2(this, _YargsInstance_usage, __classPrivateFieldGet2(this, _YargsInstance_usage, "f"), "f"); + __classPrivateFieldSet2(this, _YargsInstance_validation, __classPrivateFieldGet2(this, _YargsInstance_validation, "f"), "f"); + __classPrivateFieldSet2(this, _YargsInstance_options, __classPrivateFieldGet2(this, _YargsInstance_options, "f"), "f"); + __classPrivateFieldGet2(this, _YargsInstance_options, "f").showHiddenOpt = __classPrivateFieldGet2(this, _YargsInstance_defaultShowHiddenOpt, "f"); + __classPrivateFieldSet2(this, _YargsInstance_logger, this[kCreateLogger](), "f"); + } + addHelpOpt(opt, msg) { + const defaultHelpOpt = "help"; + argsert("[string|boolean] [string]", [opt, msg], arguments.length); + if (__classPrivateFieldGet2(this, _YargsInstance_helpOpt, "f")) { + this[kDeleteFromParserHintObject](__classPrivateFieldGet2(this, _YargsInstance_helpOpt, "f")); + __classPrivateFieldSet2(this, _YargsInstance_helpOpt, null, "f"); + } + if (opt === false && msg === void 0) + return this; + __classPrivateFieldSet2(this, _YargsInstance_helpOpt, typeof opt === "string" ? opt : defaultHelpOpt, "f"); + this.boolean(__classPrivateFieldGet2(this, _YargsInstance_helpOpt, "f")); + this.describe(__classPrivateFieldGet2(this, _YargsInstance_helpOpt, "f"), msg || __classPrivateFieldGet2(this, _YargsInstance_usage, "f").deferY18nLookup("Show help")); + return this; + } + help(opt, msg) { + return this.addHelpOpt(opt, msg); + } + addShowHiddenOpt(opt, msg) { + argsert("[string|boolean] [string]", [opt, msg], arguments.length); + if (opt === false && msg === void 0) + return this; + const showHiddenOpt = typeof opt === "string" ? opt : __classPrivateFieldGet2(this, _YargsInstance_defaultShowHiddenOpt, "f"); + this.boolean(showHiddenOpt); + this.describe(showHiddenOpt, msg || __classPrivateFieldGet2(this, _YargsInstance_usage, "f").deferY18nLookup("Show hidden options")); + __classPrivateFieldGet2(this, _YargsInstance_options, "f").showHiddenOpt = showHiddenOpt; + return this; + } + showHidden(opt, msg) { + return this.addShowHiddenOpt(opt, msg); + } + alias(key, value) { + argsert(" [string|array]", [key, value], arguments.length); + this[kPopulateParserHintArrayDictionary](this.alias.bind(this), "alias", key, value); + return this; + } + array(keys) { + argsert("", [keys], arguments.length); + this[kPopulateParserHintArray]("array", keys); + this[kTrackManuallySetKeys](keys); + return this; + } + boolean(keys) { + argsert("", [keys], arguments.length); + this[kPopulateParserHintArray]("boolean", keys); + this[kTrackManuallySetKeys](keys); + return this; + } + check(f, global2) { + argsert(" [boolean]", [f, global2], arguments.length); + this.middleware((argv, _yargs) => { + return maybeAsyncResult(() => { + return f(argv, _yargs.getOptions()); + }, (result) => { + if (!result) { + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").fail(__classPrivateFieldGet2(this, _YargsInstance_shim, "f").y18n.__("Argument check failed: %s", f.toString())); + } else if (typeof result === "string" || result instanceof Error) { + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").fail(result.toString(), result); + } + return argv; + }, (err) => { + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").fail(err.message ? err.message : err.toString(), err); + return argv; + }); + }, false, global2); + return this; + } + choices(key, value) { + argsert(" [string|array]", [key, value], arguments.length); + this[kPopulateParserHintArrayDictionary](this.choices.bind(this), "choices", key, value); + return this; + } + coerce(keys, value) { + argsert(" [function]", [keys, value], arguments.length); + if (Array.isArray(keys)) { + if (!value) { + throw new YError("coerce callback must be provided"); + } + for (const key of keys) { + this.coerce(key, value); + } + return this; + } else if (typeof keys === "object") { + for (const key of Object.keys(keys)) { + this.coerce(key, keys[key]); + } + return this; + } + if (!value) { + throw new YError("coerce callback must be provided"); + } + __classPrivateFieldGet2(this, _YargsInstance_options, "f").key[keys] = true; + __classPrivateFieldGet2(this, _YargsInstance_globalMiddleware, "f").addCoerceMiddleware((argv, yargs) => { + let aliases; + const shouldCoerce = Object.prototype.hasOwnProperty.call(argv, keys); + if (!shouldCoerce) { + return argv; + } + return maybeAsyncResult(() => { + aliases = yargs.getAliases(); + return value(argv[keys]); + }, (result) => { + argv[keys] = result; + const stripAliased = yargs.getInternalMethods().getParserConfiguration()["strip-aliased"]; + if (aliases[keys] && stripAliased !== true) { + for (const alias of aliases[keys]) { + argv[alias] = result; + } + } + return argv; + }, (err) => { + throw new YError(err.message); + }); + }, keys); + return this; + } + conflicts(key1, key2) { + argsert(" [string|array]", [key1, key2], arguments.length); + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").conflicts(key1, key2); + return this; + } + config(key = "config", msg, parseFn) { + argsert("[object|string] [string|function] [function]", [key, msg, parseFn], arguments.length); + if (typeof key === "object" && !Array.isArray(key)) { + key = applyExtends(key, __classPrivateFieldGet2(this, _YargsInstance_cwd, "f"), this[kGetParserConfiguration]()["deep-merge-config"] || false, __classPrivateFieldGet2(this, _YargsInstance_shim, "f")); + __classPrivateFieldGet2(this, _YargsInstance_options, "f").configObjects = (__classPrivateFieldGet2(this, _YargsInstance_options, "f").configObjects || []).concat(key); + return this; + } + if (typeof msg === "function") { + parseFn = msg; + msg = void 0; + } + this.describe(key, msg || __classPrivateFieldGet2(this, _YargsInstance_usage, "f").deferY18nLookup("Path to JSON config file")); + (Array.isArray(key) ? key : [key]).forEach((k) => { + __classPrivateFieldGet2(this, _YargsInstance_options, "f").config[k] = parseFn || true; + }); + return this; + } + completion(cmd, desc, fn) { + argsert("[string] [string|boolean|function] [function]", [cmd, desc, fn], arguments.length); + if (typeof desc === "function") { + fn = desc; + desc = void 0; + } + __classPrivateFieldSet2(this, _YargsInstance_completionCommand, cmd || __classPrivateFieldGet2(this, _YargsInstance_completionCommand, "f") || "completion", "f"); + if (!desc && desc !== false) { + desc = "generate completion script"; + } + this.command(__classPrivateFieldGet2(this, _YargsInstance_completionCommand, "f"), desc); + if (fn) + __classPrivateFieldGet2(this, _YargsInstance_completion, "f").registerFunction(fn); + return this; + } + command(cmd, description, builder, handler, middlewares, deprecated) { + argsert(" [string|boolean] [function|object] [function] [array] [boolean|string]", [cmd, description, builder, handler, middlewares, deprecated], arguments.length); + __classPrivateFieldGet2(this, _YargsInstance_command, "f").addHandler(cmd, description, builder, handler, middlewares, deprecated); + return this; + } + commands(cmd, description, builder, handler, middlewares, deprecated) { + return this.command(cmd, description, builder, handler, middlewares, deprecated); + } + commandDir(dir, opts) { + argsert(" [object]", [dir, opts], arguments.length); + const req = __classPrivateFieldGet2(this, _YargsInstance_parentRequire, "f") || __classPrivateFieldGet2(this, _YargsInstance_shim, "f").require; + __classPrivateFieldGet2(this, _YargsInstance_command, "f").addDirectory(dir, req, __classPrivateFieldGet2(this, _YargsInstance_shim, "f").getCallerFile(), opts); + return this; + } + count(keys) { + argsert("", [keys], arguments.length); + this[kPopulateParserHintArray]("count", keys); + this[kTrackManuallySetKeys](keys); + return this; + } + default(key, value, defaultDescription) { + argsert(" [*] [string]", [key, value, defaultDescription], arguments.length); + if (defaultDescription) { + assertSingleKey(key, __classPrivateFieldGet2(this, _YargsInstance_shim, "f")); + __classPrivateFieldGet2(this, _YargsInstance_options, "f").defaultDescription[key] = defaultDescription; + } + if (typeof value === "function") { + assertSingleKey(key, __classPrivateFieldGet2(this, _YargsInstance_shim, "f")); + if (!__classPrivateFieldGet2(this, _YargsInstance_options, "f").defaultDescription[key]) + __classPrivateFieldGet2(this, _YargsInstance_options, "f").defaultDescription[key] = __classPrivateFieldGet2(this, _YargsInstance_usage, "f").functionDescription(value); + value = value.call(); + } + this[kPopulateParserHintSingleValueDictionary](this.default.bind(this), "default", key, value); + return this; + } + defaults(key, value, defaultDescription) { + return this.default(key, value, defaultDescription); + } + demandCommand(min = 1, max, minMsg, maxMsg) { + argsert("[number] [number|string] [string|null|undefined] [string|null|undefined]", [min, max, minMsg, maxMsg], arguments.length); + if (typeof max !== "number") { + minMsg = max; + max = Infinity; + } + this.global("_", false); + __classPrivateFieldGet2(this, _YargsInstance_options, "f").demandedCommands._ = { + min, + max, + minMsg, + maxMsg + }; + return this; + } + demand(keys, max, msg) { + if (Array.isArray(max)) { + max.forEach((key) => { + assertNotStrictEqual(msg, true, __classPrivateFieldGet2(this, _YargsInstance_shim, "f")); + this.demandOption(key, msg); + }); + max = Infinity; + } else if (typeof max !== "number") { + msg = max; + max = Infinity; + } + if (typeof keys === "number") { + assertNotStrictEqual(msg, true, __classPrivateFieldGet2(this, _YargsInstance_shim, "f")); + this.demandCommand(keys, max, msg, msg); + } else if (Array.isArray(keys)) { + keys.forEach((key) => { + assertNotStrictEqual(msg, true, __classPrivateFieldGet2(this, _YargsInstance_shim, "f")); + this.demandOption(key, msg); + }); + } else { + if (typeof msg === "string") { + this.demandOption(keys, msg); + } else if (msg === true || typeof msg === "undefined") { + this.demandOption(keys); + } + } + return this; + } + demandOption(keys, msg) { + argsert(" [string]", [keys, msg], arguments.length); + this[kPopulateParserHintSingleValueDictionary](this.demandOption.bind(this), "demandedOptions", keys, msg); + return this; + } + deprecateOption(option, message) { + argsert(" [string|boolean]", [option, message], arguments.length); + __classPrivateFieldGet2(this, _YargsInstance_options, "f").deprecatedOptions[option] = message; + return this; + } + describe(keys, description) { + argsert(" [string]", [keys, description], arguments.length); + this[kSetKey](keys, true); + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").describe(keys, description); + return this; + } + detectLocale(detect) { + argsert("", [detect], arguments.length); + __classPrivateFieldSet2(this, _YargsInstance_detectLocale, detect, "f"); + return this; + } + env(prefix) { + argsert("[string|boolean]", [prefix], arguments.length); + if (prefix === false) + delete __classPrivateFieldGet2(this, _YargsInstance_options, "f").envPrefix; + else + __classPrivateFieldGet2(this, _YargsInstance_options, "f").envPrefix = prefix || ""; + return this; + } + epilogue(msg) { + argsert("", [msg], arguments.length); + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").epilog(msg); + return this; + } + epilog(msg) { + return this.epilogue(msg); + } + example(cmd, description) { + argsert(" [string]", [cmd, description], arguments.length); + if (Array.isArray(cmd)) { + cmd.forEach((exampleParams) => this.example(...exampleParams)); + } else { + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").example(cmd, description); + } + return this; + } + exit(code, err) { + __classPrivateFieldSet2(this, _YargsInstance_hasOutput, true, "f"); + __classPrivateFieldSet2(this, _YargsInstance_exitError, err, "f"); + if (__classPrivateFieldGet2(this, _YargsInstance_exitProcess, "f")) + __classPrivateFieldGet2(this, _YargsInstance_shim, "f").process.exit(code); + } + exitProcess(enabled = true) { + argsert("[boolean]", [enabled], arguments.length); + __classPrivateFieldSet2(this, _YargsInstance_exitProcess, enabled, "f"); + return this; + } + fail(f) { + argsert("", [f], arguments.length); + if (typeof f === "boolean" && f !== false) { + throw new YError("Invalid first argument. Expected function or boolean 'false'"); + } + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").failFn(f); + return this; + } + getAliases() { + return this.parsed ? this.parsed.aliases : {}; + } + async getCompletion(args, done) { + argsert(" [function]", [args, done], arguments.length); + if (!done) { + return new Promise((resolve5, reject) => { + __classPrivateFieldGet2(this, _YargsInstance_completion, "f").getCompletion(args, (err, completions) => { + if (err) + reject(err); + else + resolve5(completions); + }); + }); + } else { + return __classPrivateFieldGet2(this, _YargsInstance_completion, "f").getCompletion(args, done); + } + } + getDemandedOptions() { + argsert([], 0); + return __classPrivateFieldGet2(this, _YargsInstance_options, "f").demandedOptions; + } + getDemandedCommands() { + argsert([], 0); + return __classPrivateFieldGet2(this, _YargsInstance_options, "f").demandedCommands; + } + getDeprecatedOptions() { + argsert([], 0); + return __classPrivateFieldGet2(this, _YargsInstance_options, "f").deprecatedOptions; + } + getDetectLocale() { + return __classPrivateFieldGet2(this, _YargsInstance_detectLocale, "f"); + } + getExitProcess() { + return __classPrivateFieldGet2(this, _YargsInstance_exitProcess, "f"); + } + getGroups() { + return Object.assign({}, __classPrivateFieldGet2(this, _YargsInstance_groups, "f"), __classPrivateFieldGet2(this, _YargsInstance_preservedGroups, "f")); + } + getHelp() { + __classPrivateFieldSet2(this, _YargsInstance_hasOutput, true, "f"); + if (!__classPrivateFieldGet2(this, _YargsInstance_usage, "f").hasCachedHelpMessage()) { + if (!this.parsed) { + const parse = this[kRunYargsParserAndExecuteCommands](__classPrivateFieldGet2(this, _YargsInstance_processArgs, "f"), void 0, void 0, 0, true); + if (isPromise(parse)) { + return parse.then(() => { + return __classPrivateFieldGet2(this, _YargsInstance_usage, "f").help(); + }); + } + } + const builderResponse = __classPrivateFieldGet2(this, _YargsInstance_command, "f").runDefaultBuilderOn(this); + if (isPromise(builderResponse)) { + return builderResponse.then(() => { + return __classPrivateFieldGet2(this, _YargsInstance_usage, "f").help(); + }); + } + } + return Promise.resolve(__classPrivateFieldGet2(this, _YargsInstance_usage, "f").help()); + } + getOptions() { + return __classPrivateFieldGet2(this, _YargsInstance_options, "f"); + } + getStrict() { + return __classPrivateFieldGet2(this, _YargsInstance_strict, "f"); + } + getStrictCommands() { + return __classPrivateFieldGet2(this, _YargsInstance_strictCommands, "f"); + } + getStrictOptions() { + return __classPrivateFieldGet2(this, _YargsInstance_strictOptions, "f"); + } + global(globals, global2) { + argsert(" [boolean]", [globals, global2], arguments.length); + globals = [].concat(globals); + if (global2 !== false) { + __classPrivateFieldGet2(this, _YargsInstance_options, "f").local = __classPrivateFieldGet2(this, _YargsInstance_options, "f").local.filter((l) => globals.indexOf(l) === -1); + } else { + globals.forEach((g) => { + if (!__classPrivateFieldGet2(this, _YargsInstance_options, "f").local.includes(g)) + __classPrivateFieldGet2(this, _YargsInstance_options, "f").local.push(g); + }); + } + return this; + } + group(opts, groupName) { + argsert(" ", [opts, groupName], arguments.length); + const existing = __classPrivateFieldGet2(this, _YargsInstance_preservedGroups, "f")[groupName] || __classPrivateFieldGet2(this, _YargsInstance_groups, "f")[groupName]; + if (__classPrivateFieldGet2(this, _YargsInstance_preservedGroups, "f")[groupName]) { + delete __classPrivateFieldGet2(this, _YargsInstance_preservedGroups, "f")[groupName]; + } + const seen = {}; + __classPrivateFieldGet2(this, _YargsInstance_groups, "f")[groupName] = (existing || []).concat(opts).filter((key) => { + if (seen[key]) + return false; + return seen[key] = true; + }); + return this; + } + hide(key) { + argsert("", [key], arguments.length); + __classPrivateFieldGet2(this, _YargsInstance_options, "f").hiddenOptions.push(key); + return this; + } + implies(key, value) { + argsert(" [number|string|array]", [key, value], arguments.length); + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").implies(key, value); + return this; + } + locale(locale) { + argsert("[string]", [locale], arguments.length); + if (locale === void 0) { + this[kGuessLocale](); + return __classPrivateFieldGet2(this, _YargsInstance_shim, "f").y18n.getLocale(); + } + __classPrivateFieldSet2(this, _YargsInstance_detectLocale, false, "f"); + __classPrivateFieldGet2(this, _YargsInstance_shim, "f").y18n.setLocale(locale); + return this; + } + middleware(callback, applyBeforeValidation, global2) { + return __classPrivateFieldGet2(this, _YargsInstance_globalMiddleware, "f").addMiddleware(callback, !!applyBeforeValidation, global2); + } + nargs(key, value) { + argsert(" [number]", [key, value], arguments.length); + this[kPopulateParserHintSingleValueDictionary](this.nargs.bind(this), "narg", key, value); + return this; + } + normalize(keys) { + argsert("", [keys], arguments.length); + this[kPopulateParserHintArray]("normalize", keys); + return this; + } + number(keys) { + argsert("", [keys], arguments.length); + this[kPopulateParserHintArray]("number", keys); + this[kTrackManuallySetKeys](keys); + return this; + } + option(key, opt) { + argsert(" [object]", [key, opt], arguments.length); + if (typeof key === "object") { + Object.keys(key).forEach((k) => { + this.options(k, key[k]); + }); + } else { + if (typeof opt !== "object") { + opt = {}; + } + this[kTrackManuallySetKeys](key); + if (__classPrivateFieldGet2(this, _YargsInstance_versionOpt, "f") && (key === "version" || (opt === null || opt === void 0 ? void 0 : opt.alias) === "version")) { + this[kEmitWarning]([ + '"version" is a reserved word.', + "Please do one of the following:", + '- Disable version with `yargs.version(false)` if using "version" as an option', + "- Use the built-in `yargs.version` method instead (if applicable)", + "- Use a different option key", + "https://yargs.js.org/docs/#api-reference-version" + ].join("\n"), void 0, "versionWarning"); + } + __classPrivateFieldGet2(this, _YargsInstance_options, "f").key[key] = true; + if (opt.alias) + this.alias(key, opt.alias); + const deprecate = opt.deprecate || opt.deprecated; + if (deprecate) { + this.deprecateOption(key, deprecate); + } + const demand = opt.demand || opt.required || opt.require; + if (demand) { + this.demand(key, demand); + } + if (opt.demandOption) { + this.demandOption(key, typeof opt.demandOption === "string" ? opt.demandOption : void 0); + } + if (opt.conflicts) { + this.conflicts(key, opt.conflicts); + } + if ("default" in opt) { + this.default(key, opt.default); + } + if (opt.implies !== void 0) { + this.implies(key, opt.implies); + } + if (opt.nargs !== void 0) { + this.nargs(key, opt.nargs); + } + if (opt.config) { + this.config(key, opt.configParser); + } + if (opt.normalize) { + this.normalize(key); + } + if (opt.choices) { + this.choices(key, opt.choices); + } + if (opt.coerce) { + this.coerce(key, opt.coerce); + } + if (opt.group) { + this.group(key, opt.group); + } + if (opt.boolean || opt.type === "boolean") { + this.boolean(key); + if (opt.alias) + this.boolean(opt.alias); + } + if (opt.array || opt.type === "array") { + this.array(key); + if (opt.alias) + this.array(opt.alias); + } + if (opt.number || opt.type === "number") { + this.number(key); + if (opt.alias) + this.number(opt.alias); + } + if (opt.string || opt.type === "string") { + this.string(key); + if (opt.alias) + this.string(opt.alias); + } + if (opt.count || opt.type === "count") { + this.count(key); + } + if (typeof opt.global === "boolean") { + this.global(key, opt.global); + } + if (opt.defaultDescription) { + __classPrivateFieldGet2(this, _YargsInstance_options, "f").defaultDescription[key] = opt.defaultDescription; + } + if (opt.skipValidation) { + this.skipValidation(key); + } + const desc = opt.describe || opt.description || opt.desc; + const descriptions = __classPrivateFieldGet2(this, _YargsInstance_usage, "f").getDescriptions(); + if (!Object.prototype.hasOwnProperty.call(descriptions, key) || typeof desc === "string") { + this.describe(key, desc); + } + if (opt.hidden) { + this.hide(key); + } + if (opt.requiresArg) { + this.requiresArg(key); + } + } + return this; + } + options(key, opt) { + return this.option(key, opt); + } + parse(args, shortCircuit, _parseFn) { + argsert("[string|array] [function|boolean|object] [function]", [args, shortCircuit, _parseFn], arguments.length); + this[kFreeze](); + if (typeof args === "undefined") { + args = __classPrivateFieldGet2(this, _YargsInstance_processArgs, "f"); + } + if (typeof shortCircuit === "object") { + __classPrivateFieldSet2(this, _YargsInstance_parseContext, shortCircuit, "f"); + shortCircuit = _parseFn; + } + if (typeof shortCircuit === "function") { + __classPrivateFieldSet2(this, _YargsInstance_parseFn, shortCircuit, "f"); + shortCircuit = false; + } + if (!shortCircuit) + __classPrivateFieldSet2(this, _YargsInstance_processArgs, args, "f"); + if (__classPrivateFieldGet2(this, _YargsInstance_parseFn, "f")) + __classPrivateFieldSet2(this, _YargsInstance_exitProcess, false, "f"); + const parsed = this[kRunYargsParserAndExecuteCommands](args, !!shortCircuit); + const tmpParsed = this.parsed; + __classPrivateFieldGet2(this, _YargsInstance_completion, "f").setParsed(this.parsed); + if (isPromise(parsed)) { + return parsed.then((argv) => { + if (__classPrivateFieldGet2(this, _YargsInstance_parseFn, "f")) + __classPrivateFieldGet2(this, _YargsInstance_parseFn, "f").call(this, __classPrivateFieldGet2(this, _YargsInstance_exitError, "f"), argv, __classPrivateFieldGet2(this, _YargsInstance_output, "f")); + return argv; + }).catch((err) => { + if (__classPrivateFieldGet2(this, _YargsInstance_parseFn, "f")) { + __classPrivateFieldGet2(this, _YargsInstance_parseFn, "f")(err, this.parsed.argv, __classPrivateFieldGet2(this, _YargsInstance_output, "f")); + } + throw err; + }).finally(() => { + this[kUnfreeze](); + this.parsed = tmpParsed; + }); + } else { + if (__classPrivateFieldGet2(this, _YargsInstance_parseFn, "f")) + __classPrivateFieldGet2(this, _YargsInstance_parseFn, "f").call(this, __classPrivateFieldGet2(this, _YargsInstance_exitError, "f"), parsed, __classPrivateFieldGet2(this, _YargsInstance_output, "f")); + this[kUnfreeze](); + this.parsed = tmpParsed; + } + return parsed; + } + parseAsync(args, shortCircuit, _parseFn) { + const maybePromise = this.parse(args, shortCircuit, _parseFn); + return !isPromise(maybePromise) ? Promise.resolve(maybePromise) : maybePromise; + } + parseSync(args, shortCircuit, _parseFn) { + const maybePromise = this.parse(args, shortCircuit, _parseFn); + if (isPromise(maybePromise)) { + throw new YError(".parseSync() must not be used with asynchronous builders, handlers, or middleware"); + } + return maybePromise; + } + parserConfiguration(config2) { + argsert("", [config2], arguments.length); + __classPrivateFieldSet2(this, _YargsInstance_parserConfig, config2, "f"); + return this; + } + pkgConf(key, rootPath) { + argsert(" [string]", [key, rootPath], arguments.length); + let conf = null; + const obj = this[kPkgUp](rootPath || __classPrivateFieldGet2(this, _YargsInstance_cwd, "f")); + if (obj[key] && typeof obj[key] === "object") { + conf = applyExtends(obj[key], rootPath || __classPrivateFieldGet2(this, _YargsInstance_cwd, "f"), this[kGetParserConfiguration]()["deep-merge-config"] || false, __classPrivateFieldGet2(this, _YargsInstance_shim, "f")); + __classPrivateFieldGet2(this, _YargsInstance_options, "f").configObjects = (__classPrivateFieldGet2(this, _YargsInstance_options, "f").configObjects || []).concat(conf); + } + return this; + } + positional(key, opts) { + argsert(" ", [key, opts], arguments.length); + const supportedOpts = [ + "default", + "defaultDescription", + "implies", + "normalize", + "choices", + "conflicts", + "coerce", + "type", + "describe", + "desc", + "description", + "alias" + ]; + opts = objFilter(opts, (k, v) => { + if (k === "type" && !["string", "number", "boolean"].includes(v)) + return false; + return supportedOpts.includes(k); + }); + const fullCommand = __classPrivateFieldGet2(this, _YargsInstance_context, "f").fullCommands[__classPrivateFieldGet2(this, _YargsInstance_context, "f").fullCommands.length - 1]; + const parseOptions = fullCommand ? __classPrivateFieldGet2(this, _YargsInstance_command, "f").cmdToParseOptions(fullCommand) : { + array: [], + alias: {}, + default: {}, + demand: {} + }; + objectKeys(parseOptions).forEach((pk) => { + const parseOption = parseOptions[pk]; + if (Array.isArray(parseOption)) { + if (parseOption.indexOf(key) !== -1) + opts[pk] = true; + } else { + if (parseOption[key] && !(pk in opts)) + opts[pk] = parseOption[key]; + } + }); + this.group(key, __classPrivateFieldGet2(this, _YargsInstance_usage, "f").getPositionalGroupName()); + return this.option(key, opts); + } + recommendCommands(recommend = true) { + argsert("[boolean]", [recommend], arguments.length); + __classPrivateFieldSet2(this, _YargsInstance_recommendCommands, recommend, "f"); + return this; + } + required(keys, max, msg) { + return this.demand(keys, max, msg); + } + require(keys, max, msg) { + return this.demand(keys, max, msg); + } + requiresArg(keys) { + argsert(" [number]", [keys], arguments.length); + if (typeof keys === "string" && __classPrivateFieldGet2(this, _YargsInstance_options, "f").narg[keys]) { + return this; + } else { + this[kPopulateParserHintSingleValueDictionary](this.requiresArg.bind(this), "narg", keys, NaN); + } + return this; + } + showCompletionScript($0, cmd) { + argsert("[string] [string]", [$0, cmd], arguments.length); + $0 = $0 || this.$0; + __classPrivateFieldGet2(this, _YargsInstance_logger, "f").log(__classPrivateFieldGet2(this, _YargsInstance_completion, "f").generateCompletionScript($0, cmd || __classPrivateFieldGet2(this, _YargsInstance_completionCommand, "f") || "completion")); + return this; + } + showHelp(level) { + argsert("[string|function]", [level], arguments.length); + __classPrivateFieldSet2(this, _YargsInstance_hasOutput, true, "f"); + if (!__classPrivateFieldGet2(this, _YargsInstance_usage, "f").hasCachedHelpMessage()) { + if (!this.parsed) { + const parse = this[kRunYargsParserAndExecuteCommands](__classPrivateFieldGet2(this, _YargsInstance_processArgs, "f"), void 0, void 0, 0, true); + if (isPromise(parse)) { + parse.then(() => { + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").showHelp(level); + }); + return this; + } + } + const builderResponse = __classPrivateFieldGet2(this, _YargsInstance_command, "f").runDefaultBuilderOn(this); + if (isPromise(builderResponse)) { + builderResponse.then(() => { + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").showHelp(level); + }); + return this; + } + } + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").showHelp(level); + return this; + } + scriptName(scriptName) { + this.customScriptName = true; + this.$0 = scriptName; + return this; + } + showHelpOnFail(enabled, message) { + argsert("[boolean|string] [string]", [enabled, message], arguments.length); + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").showHelpOnFail(enabled, message); + return this; + } + showVersion(level) { + argsert("[string|function]", [level], arguments.length); + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").showVersion(level); + return this; + } + skipValidation(keys) { + argsert("", [keys], arguments.length); + this[kPopulateParserHintArray]("skipValidation", keys); + return this; + } + strict(enabled) { + argsert("[boolean]", [enabled], arguments.length); + __classPrivateFieldSet2(this, _YargsInstance_strict, enabled !== false, "f"); + return this; + } + strictCommands(enabled) { + argsert("[boolean]", [enabled], arguments.length); + __classPrivateFieldSet2(this, _YargsInstance_strictCommands, enabled !== false, "f"); + return this; + } + strictOptions(enabled) { + argsert("[boolean]", [enabled], arguments.length); + __classPrivateFieldSet2(this, _YargsInstance_strictOptions, enabled !== false, "f"); + return this; + } + string(keys) { + argsert("", [keys], arguments.length); + this[kPopulateParserHintArray]("string", keys); + this[kTrackManuallySetKeys](keys); + return this; + } + terminalWidth() { + argsert([], 0); + return __classPrivateFieldGet2(this, _YargsInstance_shim, "f").process.stdColumns; + } + updateLocale(obj) { + return this.updateStrings(obj); + } + updateStrings(obj) { + argsert("", [obj], arguments.length); + __classPrivateFieldSet2(this, _YargsInstance_detectLocale, false, "f"); + __classPrivateFieldGet2(this, _YargsInstance_shim, "f").y18n.updateLocale(obj); + return this; + } + usage(msg, description, builder, handler) { + argsert(" [string|boolean] [function|object] [function]", [msg, description, builder, handler], arguments.length); + if (description !== void 0) { + assertNotStrictEqual(msg, null, __classPrivateFieldGet2(this, _YargsInstance_shim, "f")); + if ((msg || "").match(/^\$0( |$)/)) { + return this.command(msg, description, builder, handler); + } else { + throw new YError(".usage() description must start with $0 if being used as alias for .command()"); + } + } else { + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").usage(msg); + return this; + } + } + usageConfiguration(config2) { + argsert("", [config2], arguments.length); + __classPrivateFieldSet2(this, _YargsInstance_usageConfig, config2, "f"); + return this; + } + version(opt, msg, ver) { + const defaultVersionOpt = "version"; + argsert("[boolean|string] [string] [string]", [opt, msg, ver], arguments.length); + if (__classPrivateFieldGet2(this, _YargsInstance_versionOpt, "f")) { + this[kDeleteFromParserHintObject](__classPrivateFieldGet2(this, _YargsInstance_versionOpt, "f")); + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").version(void 0); + __classPrivateFieldSet2(this, _YargsInstance_versionOpt, null, "f"); + } + if (arguments.length === 0) { + ver = this[kGuessVersion](); + opt = defaultVersionOpt; + } else if (arguments.length === 1) { + if (opt === false) { + return this; + } + ver = opt; + opt = defaultVersionOpt; + } else if (arguments.length === 2) { + ver = msg; + msg = void 0; + } + __classPrivateFieldSet2(this, _YargsInstance_versionOpt, typeof opt === "string" ? opt : defaultVersionOpt, "f"); + msg = msg || __classPrivateFieldGet2(this, _YargsInstance_usage, "f").deferY18nLookup("Show version number"); + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").version(ver || void 0); + this.boolean(__classPrivateFieldGet2(this, _YargsInstance_versionOpt, "f")); + this.describe(__classPrivateFieldGet2(this, _YargsInstance_versionOpt, "f"), msg); + return this; + } + wrap(cols) { + argsert("", [cols], arguments.length); + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").wrap(cols); + return this; + } + [(_YargsInstance_command = /* @__PURE__ */ new WeakMap(), _YargsInstance_cwd = /* @__PURE__ */ new WeakMap(), _YargsInstance_context = /* @__PURE__ */ new WeakMap(), _YargsInstance_completion = /* @__PURE__ */ new WeakMap(), _YargsInstance_completionCommand = /* @__PURE__ */ new WeakMap(), _YargsInstance_defaultShowHiddenOpt = /* @__PURE__ */ new WeakMap(), _YargsInstance_exitError = /* @__PURE__ */ new WeakMap(), _YargsInstance_detectLocale = /* @__PURE__ */ new WeakMap(), _YargsInstance_emittedWarnings = /* @__PURE__ */ new WeakMap(), _YargsInstance_exitProcess = /* @__PURE__ */ new WeakMap(), _YargsInstance_frozens = /* @__PURE__ */ new WeakMap(), _YargsInstance_globalMiddleware = /* @__PURE__ */ new WeakMap(), _YargsInstance_groups = /* @__PURE__ */ new WeakMap(), _YargsInstance_hasOutput = /* @__PURE__ */ new WeakMap(), _YargsInstance_helpOpt = /* @__PURE__ */ new WeakMap(), _YargsInstance_isGlobalContext = /* @__PURE__ */ new WeakMap(), _YargsInstance_logger = /* @__PURE__ */ new WeakMap(), _YargsInstance_output = /* @__PURE__ */ new WeakMap(), _YargsInstance_options = /* @__PURE__ */ new WeakMap(), _YargsInstance_parentRequire = /* @__PURE__ */ new WeakMap(), _YargsInstance_parserConfig = /* @__PURE__ */ new WeakMap(), _YargsInstance_parseFn = /* @__PURE__ */ new WeakMap(), _YargsInstance_parseContext = /* @__PURE__ */ new WeakMap(), _YargsInstance_pkgs = /* @__PURE__ */ new WeakMap(), _YargsInstance_preservedGroups = /* @__PURE__ */ new WeakMap(), _YargsInstance_processArgs = /* @__PURE__ */ new WeakMap(), _YargsInstance_recommendCommands = /* @__PURE__ */ new WeakMap(), _YargsInstance_shim = /* @__PURE__ */ new WeakMap(), _YargsInstance_strict = /* @__PURE__ */ new WeakMap(), _YargsInstance_strictCommands = /* @__PURE__ */ new WeakMap(), _YargsInstance_strictOptions = /* @__PURE__ */ new WeakMap(), _YargsInstance_usage = /* @__PURE__ */ new WeakMap(), _YargsInstance_usageConfig = /* @__PURE__ */ new WeakMap(), _YargsInstance_versionOpt = /* @__PURE__ */ new WeakMap(), _YargsInstance_validation = /* @__PURE__ */ new WeakMap(), kCopyDoubleDash)](argv) { + if (!argv._ || !argv["--"]) + return argv; + argv._.push.apply(argv._, argv["--"]); + try { + delete argv["--"]; + } catch (_err) { + } + return argv; + } + [kCreateLogger]() { + return { + log: (...args) => { + if (!this[kHasParseCallback]()) + console.log(...args); + __classPrivateFieldSet2(this, _YargsInstance_hasOutput, true, "f"); + if (__classPrivateFieldGet2(this, _YargsInstance_output, "f").length) + __classPrivateFieldSet2(this, _YargsInstance_output, __classPrivateFieldGet2(this, _YargsInstance_output, "f") + "\n", "f"); + __classPrivateFieldSet2(this, _YargsInstance_output, __classPrivateFieldGet2(this, _YargsInstance_output, "f") + args.join(" "), "f"); + }, + error: (...args) => { + if (!this[kHasParseCallback]()) + console.error(...args); + __classPrivateFieldSet2(this, _YargsInstance_hasOutput, true, "f"); + if (__classPrivateFieldGet2(this, _YargsInstance_output, "f").length) + __classPrivateFieldSet2(this, _YargsInstance_output, __classPrivateFieldGet2(this, _YargsInstance_output, "f") + "\n", "f"); + __classPrivateFieldSet2(this, _YargsInstance_output, __classPrivateFieldGet2(this, _YargsInstance_output, "f") + args.join(" "), "f"); + } + }; + } + [kDeleteFromParserHintObject](optionKey) { + objectKeys(__classPrivateFieldGet2(this, _YargsInstance_options, "f")).forEach((hintKey) => { + if (((key) => key === "configObjects")(hintKey)) + return; + const hint = __classPrivateFieldGet2(this, _YargsInstance_options, "f")[hintKey]; + if (Array.isArray(hint)) { + if (hint.includes(optionKey)) + hint.splice(hint.indexOf(optionKey), 1); + } else if (typeof hint === "object") { + delete hint[optionKey]; + } + }); + delete __classPrivateFieldGet2(this, _YargsInstance_usage, "f").getDescriptions()[optionKey]; + } + [kEmitWarning](warning, type, deduplicationId) { + if (!__classPrivateFieldGet2(this, _YargsInstance_emittedWarnings, "f")[deduplicationId]) { + __classPrivateFieldGet2(this, _YargsInstance_shim, "f").process.emitWarning(warning, type); + __classPrivateFieldGet2(this, _YargsInstance_emittedWarnings, "f")[deduplicationId] = true; + } + } + [kFreeze]() { + __classPrivateFieldGet2(this, _YargsInstance_frozens, "f").push({ + options: __classPrivateFieldGet2(this, _YargsInstance_options, "f"), + configObjects: __classPrivateFieldGet2(this, _YargsInstance_options, "f").configObjects.slice(0), + exitProcess: __classPrivateFieldGet2(this, _YargsInstance_exitProcess, "f"), + groups: __classPrivateFieldGet2(this, _YargsInstance_groups, "f"), + strict: __classPrivateFieldGet2(this, _YargsInstance_strict, "f"), + strictCommands: __classPrivateFieldGet2(this, _YargsInstance_strictCommands, "f"), + strictOptions: __classPrivateFieldGet2(this, _YargsInstance_strictOptions, "f"), + completionCommand: __classPrivateFieldGet2(this, _YargsInstance_completionCommand, "f"), + output: __classPrivateFieldGet2(this, _YargsInstance_output, "f"), + exitError: __classPrivateFieldGet2(this, _YargsInstance_exitError, "f"), + hasOutput: __classPrivateFieldGet2(this, _YargsInstance_hasOutput, "f"), + parsed: this.parsed, + parseFn: __classPrivateFieldGet2(this, _YargsInstance_parseFn, "f"), + parseContext: __classPrivateFieldGet2(this, _YargsInstance_parseContext, "f") + }); + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").freeze(); + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").freeze(); + __classPrivateFieldGet2(this, _YargsInstance_command, "f").freeze(); + __classPrivateFieldGet2(this, _YargsInstance_globalMiddleware, "f").freeze(); + } + [kGetDollarZero]() { + let $0 = ""; + let default$0; + if (/\b(node|iojs|electron)(\.exe)?$/.test(__classPrivateFieldGet2(this, _YargsInstance_shim, "f").process.argv()[0])) { + default$0 = __classPrivateFieldGet2(this, _YargsInstance_shim, "f").process.argv().slice(1, 2); + } else { + default$0 = __classPrivateFieldGet2(this, _YargsInstance_shim, "f").process.argv().slice(0, 1); + } + $0 = default$0.map((x) => { + const b = this[kRebase](__classPrivateFieldGet2(this, _YargsInstance_cwd, "f"), x); + return x.match(/^(\/|([a-zA-Z]:)?\\)/) && b.length < x.length ? b : x; + }).join(" ").trim(); + if (__classPrivateFieldGet2(this, _YargsInstance_shim, "f").getEnv("_") && __classPrivateFieldGet2(this, _YargsInstance_shim, "f").getProcessArgvBin() === __classPrivateFieldGet2(this, _YargsInstance_shim, "f").getEnv("_")) { + $0 = __classPrivateFieldGet2(this, _YargsInstance_shim, "f").getEnv("_").replace(`${__classPrivateFieldGet2(this, _YargsInstance_shim, "f").path.dirname(__classPrivateFieldGet2(this, _YargsInstance_shim, "f").process.execPath())}/`, ""); + } + return $0; + } + [kGetParserConfiguration]() { + return __classPrivateFieldGet2(this, _YargsInstance_parserConfig, "f"); + } + [kGetUsageConfiguration]() { + return __classPrivateFieldGet2(this, _YargsInstance_usageConfig, "f"); + } + [kGuessLocale]() { + if (!__classPrivateFieldGet2(this, _YargsInstance_detectLocale, "f")) + return; + const locale = __classPrivateFieldGet2(this, _YargsInstance_shim, "f").getEnv("LC_ALL") || __classPrivateFieldGet2(this, _YargsInstance_shim, "f").getEnv("LC_MESSAGES") || __classPrivateFieldGet2(this, _YargsInstance_shim, "f").getEnv("LANG") || __classPrivateFieldGet2(this, _YargsInstance_shim, "f").getEnv("LANGUAGE") || "en_US"; + this.locale(locale.replace(/[.:].*/, "")); + } + [kGuessVersion]() { + const obj = this[kPkgUp](); + return obj.version || "unknown"; + } + [kParsePositionalNumbers](argv) { + const args = argv["--"] ? argv["--"] : argv._; + for (let i = 0, arg; (arg = args[i]) !== void 0; i++) { + if (__classPrivateFieldGet2(this, _YargsInstance_shim, "f").Parser.looksLikeNumber(arg) && Number.isSafeInteger(Math.floor(parseFloat(`${arg}`)))) { + args[i] = Number(arg); + } + } + return argv; + } + [kPkgUp](rootPath) { + const npath = rootPath || "*"; + if (__classPrivateFieldGet2(this, _YargsInstance_pkgs, "f")[npath]) + return __classPrivateFieldGet2(this, _YargsInstance_pkgs, "f")[npath]; + let obj = {}; + try { + let startDir = rootPath || __classPrivateFieldGet2(this, _YargsInstance_shim, "f").mainFilename; + if (!rootPath && __classPrivateFieldGet2(this, _YargsInstance_shim, "f").path.extname(startDir)) { + startDir = __classPrivateFieldGet2(this, _YargsInstance_shim, "f").path.dirname(startDir); + } + const pkgJsonPath = __classPrivateFieldGet2(this, _YargsInstance_shim, "f").findUp(startDir, (dir, names) => { + if (names.includes("package.json")) { + return "package.json"; + } else { + return void 0; + } + }); + assertNotStrictEqual(pkgJsonPath, void 0, __classPrivateFieldGet2(this, _YargsInstance_shim, "f")); + obj = JSON.parse(__classPrivateFieldGet2(this, _YargsInstance_shim, "f").readFileSync(pkgJsonPath, "utf8")); + } catch (_noop) { + } + __classPrivateFieldGet2(this, _YargsInstance_pkgs, "f")[npath] = obj || {}; + return __classPrivateFieldGet2(this, _YargsInstance_pkgs, "f")[npath]; + } + [kPopulateParserHintArray](type, keys) { + keys = [].concat(keys); + keys.forEach((key) => { + key = this[kSanitizeKey](key); + __classPrivateFieldGet2(this, _YargsInstance_options, "f")[type].push(key); + }); + } + [kPopulateParserHintSingleValueDictionary](builder, type, key, value) { + this[kPopulateParserHintDictionary](builder, type, key, value, (type2, key2, value2) => { + __classPrivateFieldGet2(this, _YargsInstance_options, "f")[type2][key2] = value2; + }); + } + [kPopulateParserHintArrayDictionary](builder, type, key, value) { + this[kPopulateParserHintDictionary](builder, type, key, value, (type2, key2, value2) => { + __classPrivateFieldGet2(this, _YargsInstance_options, "f")[type2][key2] = (__classPrivateFieldGet2(this, _YargsInstance_options, "f")[type2][key2] || []).concat(value2); + }); + } + [kPopulateParserHintDictionary](builder, type, key, value, singleKeyHandler) { + if (Array.isArray(key)) { + key.forEach((k) => { + builder(k, value); + }); + } else if (((key2) => typeof key2 === "object")(key)) { + for (const k of objectKeys(key)) { + builder(k, key[k]); + } + } else { + singleKeyHandler(type, this[kSanitizeKey](key), value); + } + } + [kSanitizeKey](key) { + if (key === "__proto__") + return "___proto___"; + return key; + } + [kSetKey](key, set) { + this[kPopulateParserHintSingleValueDictionary](this[kSetKey].bind(this), "key", key, set); + return this; + } + [kUnfreeze]() { + var _a2, _b2, _c2, _d, _e, _f, _g, _h, _j, _k, _l, _m; + const frozen = __classPrivateFieldGet2(this, _YargsInstance_frozens, "f").pop(); + assertNotStrictEqual(frozen, void 0, __classPrivateFieldGet2(this, _YargsInstance_shim, "f")); + let configObjects; + _a2 = this, _b2 = this, _c2 = this, _d = this, _e = this, _f = this, _g = this, _h = this, _j = this, _k = this, _l = this, _m = this, { + options: { set value(_o) { + __classPrivateFieldSet2(_a2, _YargsInstance_options, _o, "f"); + } }.value, + configObjects, + exitProcess: { set value(_o) { + __classPrivateFieldSet2(_b2, _YargsInstance_exitProcess, _o, "f"); + } }.value, + groups: { set value(_o) { + __classPrivateFieldSet2(_c2, _YargsInstance_groups, _o, "f"); + } }.value, + output: { set value(_o) { + __classPrivateFieldSet2(_d, _YargsInstance_output, _o, "f"); + } }.value, + exitError: { set value(_o) { + __classPrivateFieldSet2(_e, _YargsInstance_exitError, _o, "f"); + } }.value, + hasOutput: { set value(_o) { + __classPrivateFieldSet2(_f, _YargsInstance_hasOutput, _o, "f"); + } }.value, + parsed: this.parsed, + strict: { set value(_o) { + __classPrivateFieldSet2(_g, _YargsInstance_strict, _o, "f"); + } }.value, + strictCommands: { set value(_o) { + __classPrivateFieldSet2(_h, _YargsInstance_strictCommands, _o, "f"); + } }.value, + strictOptions: { set value(_o) { + __classPrivateFieldSet2(_j, _YargsInstance_strictOptions, _o, "f"); + } }.value, + completionCommand: { set value(_o) { + __classPrivateFieldSet2(_k, _YargsInstance_completionCommand, _o, "f"); + } }.value, + parseFn: { set value(_o) { + __classPrivateFieldSet2(_l, _YargsInstance_parseFn, _o, "f"); + } }.value, + parseContext: { set value(_o) { + __classPrivateFieldSet2(_m, _YargsInstance_parseContext, _o, "f"); + } }.value + } = frozen; + __classPrivateFieldGet2(this, _YargsInstance_options, "f").configObjects = configObjects; + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").unfreeze(); + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").unfreeze(); + __classPrivateFieldGet2(this, _YargsInstance_command, "f").unfreeze(); + __classPrivateFieldGet2(this, _YargsInstance_globalMiddleware, "f").unfreeze(); + } + [kValidateAsync](validation2, argv) { + return maybeAsyncResult(argv, (result) => { + validation2(result); + return result; + }); + } + getInternalMethods() { + return { + getCommandInstance: this[kGetCommandInstance].bind(this), + getContext: this[kGetContext].bind(this), + getHasOutput: this[kGetHasOutput].bind(this), + getLoggerInstance: this[kGetLoggerInstance].bind(this), + getParseContext: this[kGetParseContext].bind(this), + getParserConfiguration: this[kGetParserConfiguration].bind(this), + getUsageConfiguration: this[kGetUsageConfiguration].bind(this), + getUsageInstance: this[kGetUsageInstance].bind(this), + getValidationInstance: this[kGetValidationInstance].bind(this), + hasParseCallback: this[kHasParseCallback].bind(this), + isGlobalContext: this[kIsGlobalContext].bind(this), + postProcess: this[kPostProcess].bind(this), + reset: this[kReset].bind(this), + runValidation: this[kRunValidation].bind(this), + runYargsParserAndExecuteCommands: this[kRunYargsParserAndExecuteCommands].bind(this), + setHasOutput: this[kSetHasOutput].bind(this) + }; + } + [kGetCommandInstance]() { + return __classPrivateFieldGet2(this, _YargsInstance_command, "f"); + } + [kGetContext]() { + return __classPrivateFieldGet2(this, _YargsInstance_context, "f"); + } + [kGetHasOutput]() { + return __classPrivateFieldGet2(this, _YargsInstance_hasOutput, "f"); + } + [kGetLoggerInstance]() { + return __classPrivateFieldGet2(this, _YargsInstance_logger, "f"); + } + [kGetParseContext]() { + return __classPrivateFieldGet2(this, _YargsInstance_parseContext, "f") || {}; + } + [kGetUsageInstance]() { + return __classPrivateFieldGet2(this, _YargsInstance_usage, "f"); + } + [kGetValidationInstance]() { + return __classPrivateFieldGet2(this, _YargsInstance_validation, "f"); + } + [kHasParseCallback]() { + return !!__classPrivateFieldGet2(this, _YargsInstance_parseFn, "f"); + } + [kIsGlobalContext]() { + return __classPrivateFieldGet2(this, _YargsInstance_isGlobalContext, "f"); + } + [kPostProcess](argv, populateDoubleDash, calledFromCommand, runGlobalMiddleware) { + if (calledFromCommand) + return argv; + if (isPromise(argv)) + return argv; + if (!populateDoubleDash) { + argv = this[kCopyDoubleDash](argv); + } + const parsePositionalNumbers = this[kGetParserConfiguration]()["parse-positional-numbers"] || this[kGetParserConfiguration]()["parse-positional-numbers"] === void 0; + if (parsePositionalNumbers) { + argv = this[kParsePositionalNumbers](argv); + } + if (runGlobalMiddleware) { + argv = applyMiddleware(argv, this, __classPrivateFieldGet2(this, _YargsInstance_globalMiddleware, "f").getMiddleware(), false); + } + return argv; + } + [kReset](aliases = {}) { + __classPrivateFieldSet2(this, _YargsInstance_options, __classPrivateFieldGet2(this, _YargsInstance_options, "f") || {}, "f"); + const tmpOptions = {}; + tmpOptions.local = __classPrivateFieldGet2(this, _YargsInstance_options, "f").local || []; + tmpOptions.configObjects = __classPrivateFieldGet2(this, _YargsInstance_options, "f").configObjects || []; + const localLookup = {}; + tmpOptions.local.forEach((l) => { + localLookup[l] = true; + (aliases[l] || []).forEach((a) => { + localLookup[a] = true; + }); + }); + Object.assign(__classPrivateFieldGet2(this, _YargsInstance_preservedGroups, "f"), Object.keys(__classPrivateFieldGet2(this, _YargsInstance_groups, "f")).reduce((acc, groupName) => { + const keys = __classPrivateFieldGet2(this, _YargsInstance_groups, "f")[groupName].filter((key) => !(key in localLookup)); + if (keys.length > 0) { + acc[groupName] = keys; + } + return acc; + }, {})); + __classPrivateFieldSet2(this, _YargsInstance_groups, {}, "f"); + const arrayOptions = [ + "array", + "boolean", + "string", + "skipValidation", + "count", + "normalize", + "number", + "hiddenOptions" + ]; + const objectOptions = [ + "narg", + "key", + "alias", + "default", + "defaultDescription", + "config", + "choices", + "demandedOptions", + "demandedCommands", + "deprecatedOptions" + ]; + arrayOptions.forEach((k) => { + tmpOptions[k] = (__classPrivateFieldGet2(this, _YargsInstance_options, "f")[k] || []).filter((k2) => !localLookup[k2]); + }); + objectOptions.forEach((k) => { + tmpOptions[k] = objFilter(__classPrivateFieldGet2(this, _YargsInstance_options, "f")[k], (k2) => !localLookup[k2]); + }); + tmpOptions.envPrefix = __classPrivateFieldGet2(this, _YargsInstance_options, "f").envPrefix; + __classPrivateFieldSet2(this, _YargsInstance_options, tmpOptions, "f"); + __classPrivateFieldSet2(this, _YargsInstance_usage, __classPrivateFieldGet2(this, _YargsInstance_usage, "f") ? __classPrivateFieldGet2(this, _YargsInstance_usage, "f").reset(localLookup) : usage(this, __classPrivateFieldGet2(this, _YargsInstance_shim, "f")), "f"); + __classPrivateFieldSet2(this, _YargsInstance_validation, __classPrivateFieldGet2(this, _YargsInstance_validation, "f") ? __classPrivateFieldGet2(this, _YargsInstance_validation, "f").reset(localLookup) : validation(this, __classPrivateFieldGet2(this, _YargsInstance_usage, "f"), __classPrivateFieldGet2(this, _YargsInstance_shim, "f")), "f"); + __classPrivateFieldSet2(this, _YargsInstance_command, __classPrivateFieldGet2(this, _YargsInstance_command, "f") ? __classPrivateFieldGet2(this, _YargsInstance_command, "f").reset() : command(__classPrivateFieldGet2(this, _YargsInstance_usage, "f"), __classPrivateFieldGet2(this, _YargsInstance_validation, "f"), __classPrivateFieldGet2(this, _YargsInstance_globalMiddleware, "f"), __classPrivateFieldGet2(this, _YargsInstance_shim, "f")), "f"); + if (!__classPrivateFieldGet2(this, _YargsInstance_completion, "f")) + __classPrivateFieldSet2(this, _YargsInstance_completion, completion(this, __classPrivateFieldGet2(this, _YargsInstance_usage, "f"), __classPrivateFieldGet2(this, _YargsInstance_command, "f"), __classPrivateFieldGet2(this, _YargsInstance_shim, "f")), "f"); + __classPrivateFieldGet2(this, _YargsInstance_globalMiddleware, "f").reset(); + __classPrivateFieldSet2(this, _YargsInstance_completionCommand, null, "f"); + __classPrivateFieldSet2(this, _YargsInstance_output, "", "f"); + __classPrivateFieldSet2(this, _YargsInstance_exitError, null, "f"); + __classPrivateFieldSet2(this, _YargsInstance_hasOutput, false, "f"); + this.parsed = false; + return this; + } + [kRebase](base, dir) { + return __classPrivateFieldGet2(this, _YargsInstance_shim, "f").path.relative(base, dir); + } + [kRunYargsParserAndExecuteCommands](args, shortCircuit, calledFromCommand, commandIndex = 0, helpOnly = false) { + let skipValidation = !!calledFromCommand || helpOnly; + args = args || __classPrivateFieldGet2(this, _YargsInstance_processArgs, "f"); + __classPrivateFieldGet2(this, _YargsInstance_options, "f").__ = __classPrivateFieldGet2(this, _YargsInstance_shim, "f").y18n.__; + __classPrivateFieldGet2(this, _YargsInstance_options, "f").configuration = this[kGetParserConfiguration](); + const populateDoubleDash = !!__classPrivateFieldGet2(this, _YargsInstance_options, "f").configuration["populate--"]; + const config2 = Object.assign({}, __classPrivateFieldGet2(this, _YargsInstance_options, "f").configuration, { + "populate--": true + }); + const parsed = __classPrivateFieldGet2(this, _YargsInstance_shim, "f").Parser.detailed(args, Object.assign({}, __classPrivateFieldGet2(this, _YargsInstance_options, "f"), { + configuration: { "parse-positional-numbers": false, ...config2 } + })); + const argv = Object.assign(parsed.argv, __classPrivateFieldGet2(this, _YargsInstance_parseContext, "f")); + let argvPromise = void 0; + const aliases = parsed.aliases; + let helpOptSet = false; + let versionOptSet = false; + Object.keys(argv).forEach((key) => { + if (key === __classPrivateFieldGet2(this, _YargsInstance_helpOpt, "f") && argv[key]) { + helpOptSet = true; + } else if (key === __classPrivateFieldGet2(this, _YargsInstance_versionOpt, "f") && argv[key]) { + versionOptSet = true; + } + }); + argv.$0 = this.$0; + this.parsed = parsed; + if (commandIndex === 0) { + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").clearCachedHelpMessage(); + } + try { + this[kGuessLocale](); + if (shortCircuit) { + return this[kPostProcess](argv, populateDoubleDash, !!calledFromCommand, false); + } + if (__classPrivateFieldGet2(this, _YargsInstance_helpOpt, "f")) { + const helpCmds = [__classPrivateFieldGet2(this, _YargsInstance_helpOpt, "f")].concat(aliases[__classPrivateFieldGet2(this, _YargsInstance_helpOpt, "f")] || []).filter((k) => k.length > 1); + if (helpCmds.includes("" + argv._[argv._.length - 1])) { + argv._.pop(); + helpOptSet = true; + } + } + __classPrivateFieldSet2(this, _YargsInstance_isGlobalContext, false, "f"); + const handlerKeys = __classPrivateFieldGet2(this, _YargsInstance_command, "f").getCommands(); + const requestCompletions = __classPrivateFieldGet2(this, _YargsInstance_completion, "f").completionKey in argv; + const skipRecommendation = helpOptSet || requestCompletions || helpOnly; + if (argv._.length) { + if (handlerKeys.length) { + let firstUnknownCommand; + for (let i = commandIndex || 0, cmd; argv._[i] !== void 0; i++) { + cmd = String(argv._[i]); + if (handlerKeys.includes(cmd) && cmd !== __classPrivateFieldGet2(this, _YargsInstance_completionCommand, "f")) { + const innerArgv = __classPrivateFieldGet2(this, _YargsInstance_command, "f").runCommand(cmd, this, parsed, i + 1, helpOnly, helpOptSet || versionOptSet || helpOnly); + return this[kPostProcess](innerArgv, populateDoubleDash, !!calledFromCommand, false); + } else if (!firstUnknownCommand && cmd !== __classPrivateFieldGet2(this, _YargsInstance_completionCommand, "f")) { + firstUnknownCommand = cmd; + break; + } + } + if (!__classPrivateFieldGet2(this, _YargsInstance_command, "f").hasDefaultCommand() && __classPrivateFieldGet2(this, _YargsInstance_recommendCommands, "f") && firstUnknownCommand && !skipRecommendation) { + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").recommendCommands(firstUnknownCommand, handlerKeys); + } + } + if (__classPrivateFieldGet2(this, _YargsInstance_completionCommand, "f") && argv._.includes(__classPrivateFieldGet2(this, _YargsInstance_completionCommand, "f")) && !requestCompletions) { + if (__classPrivateFieldGet2(this, _YargsInstance_exitProcess, "f")) + setBlocking(true); + this.showCompletionScript(); + this.exit(0); + } + } + if (__classPrivateFieldGet2(this, _YargsInstance_command, "f").hasDefaultCommand() && !skipRecommendation) { + const innerArgv = __classPrivateFieldGet2(this, _YargsInstance_command, "f").runCommand(null, this, parsed, 0, helpOnly, helpOptSet || versionOptSet || helpOnly); + return this[kPostProcess](innerArgv, populateDoubleDash, !!calledFromCommand, false); + } + if (requestCompletions) { + if (__classPrivateFieldGet2(this, _YargsInstance_exitProcess, "f")) + setBlocking(true); + args = [].concat(args); + const completionArgs = args.slice(args.indexOf(`--${__classPrivateFieldGet2(this, _YargsInstance_completion, "f").completionKey}`) + 1); + __classPrivateFieldGet2(this, _YargsInstance_completion, "f").getCompletion(completionArgs, (err, completions) => { + if (err) + throw new YError(err.message); + (completions || []).forEach((completion2) => { + __classPrivateFieldGet2(this, _YargsInstance_logger, "f").log(completion2); + }); + this.exit(0); + }); + return this[kPostProcess](argv, !populateDoubleDash, !!calledFromCommand, false); + } + if (!__classPrivateFieldGet2(this, _YargsInstance_hasOutput, "f")) { + if (helpOptSet) { + if (__classPrivateFieldGet2(this, _YargsInstance_exitProcess, "f")) + setBlocking(true); + skipValidation = true; + this.showHelp("log"); + this.exit(0); + } else if (versionOptSet) { + if (__classPrivateFieldGet2(this, _YargsInstance_exitProcess, "f")) + setBlocking(true); + skipValidation = true; + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").showVersion("log"); + this.exit(0); + } + } + if (!skipValidation && __classPrivateFieldGet2(this, _YargsInstance_options, "f").skipValidation.length > 0) { + skipValidation = Object.keys(argv).some((key) => __classPrivateFieldGet2(this, _YargsInstance_options, "f").skipValidation.indexOf(key) >= 0 && argv[key] === true); + } + if (!skipValidation) { + if (parsed.error) + throw new YError(parsed.error.message); + if (!requestCompletions) { + const validation2 = this[kRunValidation](aliases, {}, parsed.error); + if (!calledFromCommand) { + argvPromise = applyMiddleware(argv, this, __classPrivateFieldGet2(this, _YargsInstance_globalMiddleware, "f").getMiddleware(), true); + } + argvPromise = this[kValidateAsync](validation2, argvPromise !== null && argvPromise !== void 0 ? argvPromise : argv); + if (isPromise(argvPromise) && !calledFromCommand) { + argvPromise = argvPromise.then(() => { + return applyMiddleware(argv, this, __classPrivateFieldGet2(this, _YargsInstance_globalMiddleware, "f").getMiddleware(), false); + }); + } + } + } + } catch (err) { + if (err instanceof YError) + __classPrivateFieldGet2(this, _YargsInstance_usage, "f").fail(err.message, err); + else + throw err; + } + return this[kPostProcess](argvPromise !== null && argvPromise !== void 0 ? argvPromise : argv, populateDoubleDash, !!calledFromCommand, true); + } + [kRunValidation](aliases, positionalMap, parseErrors, isDefaultCommand) { + const demandedOptions = { ...this.getDemandedOptions() }; + return (argv) => { + if (parseErrors) + throw new YError(parseErrors.message); + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").nonOptionCount(argv); + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").requiredArguments(argv, demandedOptions); + let failedStrictCommands = false; + if (__classPrivateFieldGet2(this, _YargsInstance_strictCommands, "f")) { + failedStrictCommands = __classPrivateFieldGet2(this, _YargsInstance_validation, "f").unknownCommands(argv); + } + if (__classPrivateFieldGet2(this, _YargsInstance_strict, "f") && !failedStrictCommands) { + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").unknownArguments(argv, aliases, positionalMap, !!isDefaultCommand); + } else if (__classPrivateFieldGet2(this, _YargsInstance_strictOptions, "f")) { + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").unknownArguments(argv, aliases, {}, false, false); + } + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").limitedChoices(argv); + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").implications(argv); + __classPrivateFieldGet2(this, _YargsInstance_validation, "f").conflicting(argv); + }; + } + [kSetHasOutput]() { + __classPrivateFieldSet2(this, _YargsInstance_hasOutput, true, "f"); + } + [kTrackManuallySetKeys](keys) { + if (typeof keys === "string") { + __classPrivateFieldGet2(this, _YargsInstance_options, "f").key[keys] = true; + } else { + for (const k of keys) { + __classPrivateFieldGet2(this, _YargsInstance_options, "f").key[k] = true; + } + } + } +}; +function isYargsInstance(y) { + return !!y && typeof y.getInternalMethods === "function"; +} + +// ../testeranto/node_modules/yargs/index.mjs +var Yargs = YargsFactory(esm_default); + +// ../testeranto/node_modules/yargs/helpers/helpers.mjs +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/BrowserLauncher.js +init_cjs_shim(); +import { existsSync } from "fs"; +import { tmpdir } from "os"; +import { join } from "path"; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/PipeTransport.js +init_cjs_shim(); +var PipeTransport = class { + #pipeWrite; + #subscriptions = new DisposableStack(); + #isClosed = false; + #pendingMessage = ""; + onclose; + onmessage; + constructor(pipeWrite, pipeRead) { + this.#pipeWrite = pipeWrite; + const pipeReadEmitter = this.#subscriptions.use( + // NodeJS event emitters don't support `*` so we need to typecast + // As long as we don't use it we should be OK. + new EventEmitter(pipeRead) + ); + pipeReadEmitter.on("data", (buffer) => { + return this.#dispatch(buffer); + }); + pipeReadEmitter.on("close", () => { + if (this.onclose) { + this.onclose.call(null); + } + }); + pipeReadEmitter.on("error", debugError); + const pipeWriteEmitter = this.#subscriptions.use( + // NodeJS event emitters don't support `*` so we need to typecast + // As long as we don't use it we should be OK. + new EventEmitter(pipeRead) + ); + pipeWriteEmitter.on("error", debugError); + } + send(message) { + assert(!this.#isClosed, "`PipeTransport` is closed."); + this.#pipeWrite.write(message); + this.#pipeWrite.write("\0"); + } + #dispatch(buffer) { + assert(!this.#isClosed, "`PipeTransport` is closed."); + let end = buffer.indexOf("\0"); + if (end === -1) { + this.#pendingMessage += buffer.toString(); + return; + } + const message = this.#pendingMessage + buffer.toString(void 0, 0, end); + if (this.onmessage) { + this.onmessage.call(null, message); + } + let start = end + 1; + end = buffer.indexOf("\0", start); + while (end !== -1) { + if (this.onmessage) { + this.onmessage.call(null, buffer.toString(void 0, start, end)); + } + start = end + 1; + end = buffer.indexOf("\0", start); + } + this.#pendingMessage = buffer.toString(void 0, start); + } + close() { + this.#isClosed = true; + this.#subscriptions.dispose(); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/BrowserLauncher.js +var BrowserLauncher = class { + #browser; + /** + * @internal + */ + puppeteer; + /** + * @internal + */ + constructor(puppeteer2, browser) { + this.puppeteer = puppeteer2; + this.#browser = browser; + } + get browser() { + return this.#browser; + } + async launch(options = {}) { + const { dumpio = false, env: env2 = process.env, handleSIGINT = true, handleSIGTERM = true, handleSIGHUP = true, acceptInsecureCerts = false, defaultViewport = DEFAULT_VIEWPORT, downloadBehavior, slowMo = 0, timeout: timeout2 = 3e4, waitForInitialPage = true, protocolTimeout } = options; + let { protocol } = options; + if (this.#browser === "firefox" && protocol === void 0) { + protocol = "webDriverBiDi"; + } + const launchArgs = await this.computeLaunchArguments({ + ...options, + protocol + }); + if (!existsSync(launchArgs.executablePath)) { + throw new Error(`Browser was not found at the configured executablePath (${launchArgs.executablePath})`); + } + const usePipe = launchArgs.args.includes("--remote-debugging-pipe"); + const onProcessExit = async () => { + await this.cleanUserDataDir(launchArgs.userDataDir, { + isTemp: launchArgs.isTempUserDataDir + }); + }; + if (this.#browser === "firefox" && protocol !== "webDriverBiDi" && this.puppeteer.configuration.logLevel === "warn") { + console.warn(`Chrome DevTools Protocol (CDP) support for Firefox is deprecated in Puppeteer and it will be eventually removed. Use WebDriver BiDi instead (see https://pptr.dev/webdriver-bidi#get-started).`); + } + if (this.#browser === "firefox" && protocol === "webDriverBiDi" && usePipe) { + throw new Error("Pipe connections are not supported wtih Firefox and WebDriver BiDi"); + } + const browserProcess = launch({ + executablePath: launchArgs.executablePath, + args: launchArgs.args, + handleSIGHUP, + handleSIGTERM, + handleSIGINT, + dumpio, + env: env2, + pipe: usePipe, + onExit: onProcessExit + }); + let browser; + let cdpConnection; + let closing = false; + const browserCloseCallback = async () => { + if (closing) { + return; + } + closing = true; + await this.closeBrowser(browserProcess, cdpConnection); + }; + try { + if (this.#browser === "firefox" && protocol === "webDriverBiDi") { + browser = await this.createBiDiBrowser(browserProcess, browserCloseCallback, { + timeout: timeout2, + protocolTimeout, + slowMo, + defaultViewport, + acceptInsecureCerts + }); + } else { + if (usePipe) { + cdpConnection = await this.createCdpPipeConnection(browserProcess, { + timeout: timeout2, + protocolTimeout, + slowMo + }); + } else { + cdpConnection = await this.createCdpSocketConnection(browserProcess, { + timeout: timeout2, + protocolTimeout, + slowMo + }); + } + if (protocol === "webDriverBiDi") { + browser = await this.createBiDiOverCdpBrowser(browserProcess, cdpConnection, browserCloseCallback, { + defaultViewport, + acceptInsecureCerts + }); + } else { + browser = await CdpBrowser._create(this.browser, cdpConnection, [], acceptInsecureCerts, defaultViewport, downloadBehavior, browserProcess.nodeProcess, browserCloseCallback, options.targetFilter); + } + } + } catch (error) { + void browserCloseCallback(); + if (error instanceof TimeoutError2) { + throw new TimeoutError(error.message); + } + throw error; + } + if (waitForInitialPage) { + await this.waitForPageTarget(browser, timeout2); + } + return browser; + } + /** + * @internal + */ + async closeBrowser(browserProcess, cdpConnection) { + if (cdpConnection) { + try { + await cdpConnection.closeBrowser(); + await browserProcess.hasClosed(); + } catch (error) { + debugError(error); + await browserProcess.close(); + } + } else { + await firstValueFrom(race(from(browserProcess.hasClosed()), timer(5e3).pipe(map(() => { + return from(browserProcess.close()); + })))); + } + } + /** + * @internal + */ + async waitForPageTarget(browser, timeout2) { + try { + await browser.waitForTarget((t) => { + return t.type() === "page"; + }, { timeout: timeout2 }); + } catch (error) { + await browser.close(); + throw error; + } + } + /** + * @internal + */ + async createCdpSocketConnection(browserProcess, opts) { + const browserWSEndpoint = await browserProcess.waitForLineOutput(CDP_WEBSOCKET_ENDPOINT_REGEX, opts.timeout); + const transport = await NodeWebSocketTransport.create(browserWSEndpoint); + return new Connection(browserWSEndpoint, transport, opts.slowMo, opts.protocolTimeout); + } + /** + * @internal + */ + async createCdpPipeConnection(browserProcess, opts) { + const { 3: pipeWrite, 4: pipeRead } = browserProcess.nodeProcess.stdio; + const transport = new PipeTransport(pipeWrite, pipeRead); + return new Connection("", transport, opts.slowMo, opts.protocolTimeout); + } + /** + * @internal + */ + async createBiDiOverCdpBrowser(browserProcess, connection, closeCallback, opts) { + const BiDi = await import( + /* webpackIgnore: true */ + "./bidi-2I2CA3WT.mjs" + ); + const bidiConnection = await BiDi.connectBidiOverCdp(connection); + return await BiDi.BidiBrowser.create({ + connection: bidiConnection, + cdpConnection: connection, + closeCallback, + process: browserProcess.nodeProcess, + defaultViewport: opts.defaultViewport, + acceptInsecureCerts: opts.acceptInsecureCerts + }); + } + /** + * @internal + */ + async createBiDiBrowser(browserProcess, closeCallback, opts) { + const browserWSEndpoint = await browserProcess.waitForLineOutput(WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX, opts.timeout) + "/session"; + const transport = await NodeWebSocketTransport.create(browserWSEndpoint); + const BiDi = await import( + /* webpackIgnore: true */ + "./bidi-2I2CA3WT.mjs" + ); + const bidiConnection = new BiDi.BidiConnection(browserWSEndpoint, transport, opts.slowMo, opts.protocolTimeout); + return await BiDi.BidiBrowser.create({ + connection: bidiConnection, + closeCallback, + process: browserProcess.nodeProcess, + defaultViewport: opts.defaultViewport, + acceptInsecureCerts: opts.acceptInsecureCerts + }); + } + /** + * @internal + */ + getProfilePath() { + return join(this.puppeteer.configuration.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`); + } + /** + * @internal + */ + resolveExecutablePath(headless) { + let executablePath2 = this.puppeteer.configuration.executablePath; + if (executablePath2) { + if (!existsSync(executablePath2)) { + throw new Error(`Tried to find the browser at the configured path (${executablePath2}), but no executable was found.`); + } + return executablePath2; + } + function puppeteerBrowserToInstalledBrowser(browser, headless2) { + switch (browser) { + case "chrome": + if (headless2 === "shell") { + return Browser2.CHROMEHEADLESSSHELL; + } + return Browser2.CHROME; + case "firefox": + return Browser2.FIREFOX; + } + return Browser2.CHROME; + } + const browserType = puppeteerBrowserToInstalledBrowser(this.browser, headless); + executablePath2 = computeExecutablePath({ + cacheDir: this.puppeteer.defaultDownloadPath, + browser: browserType, + buildId: this.puppeteer.browserVersion + }); + if (!existsSync(executablePath2)) { + const configVersion = this.puppeteer.configuration?.[this.browser]?.version; + if (configVersion) { + throw new Error(`Tried to find the browser at the configured path (${executablePath2}) for version ${configVersion}, but no executable was found.`); + } + switch (this.browser) { + case "chrome": + throw new Error(`Could not find Chrome (ver. ${this.puppeteer.browserVersion}). This can occur if either + 1. you did not perform an installation before running the script (e.g. \`npx puppeteer browsers install ${browserType}\`) or + 2. your cache path is incorrectly configured (which is: ${this.puppeteer.configuration.cacheDirectory}). +For (2), check out our guide on configuring puppeteer at https://pptr.dev/guides/configuration.`); + case "firefox": + throw new Error(`Could not find Firefox (rev. ${this.puppeteer.browserVersion}). This can occur if either + 1. you did not perform an installation for Firefox before running the script (e.g. \`npx puppeteer browsers install firefox\`) or + 2. your cache path is incorrectly configured (which is: ${this.puppeteer.configuration.cacheDirectory}). +For (2), check out our guide on configuring puppeteer at https://pptr.dev/guides/configuration.`); + } + } + return executablePath2; + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/util/fs.js +init_cjs_shim(); +import fs3 from "fs"; +var rmOptions = { + force: true, + recursive: true, + maxRetries: 5 +}; +async function rm(path10) { + await fs3.promises.rm(path10, rmOptions); +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/ChromeLauncher.js +var ChromeLauncher = class extends BrowserLauncher { + constructor(puppeteer2) { + super(puppeteer2, "chrome"); + } + launch(options = {}) { + if (this.puppeteer.configuration.logLevel === "warn" && process.platform === "darwin" && process.arch === "x64") { + const cpus = os5.cpus(); + if (cpus[0]?.model.includes("Apple")) { + console.warn([ + "\x1B[1m\x1B[43m\x1B[30m", + "Degraded performance warning:\x1B[0m\x1B[33m", + "Launching Chrome on Mac Silicon (arm64) from an x64 Node installation results in", + "Rosetta translating the Chrome binary, even if Chrome is already arm64. This would", + "result in huge performance issues. To resolve this, you must run Puppeteer with", + "a version of Node built for arm64." + ].join("\n ")); + } + } + return super.launch(options); + } + /** + * @internal + */ + async computeLaunchArguments(options = {}) { + const { ignoreDefaultArgs = false, args = [], pipe = false, debuggingPort, channel, executablePath: executablePath2 } = options; + const chromeArguments = []; + if (!ignoreDefaultArgs) { + chromeArguments.push(...this.defaultArgs(options)); + } else if (Array.isArray(ignoreDefaultArgs)) { + chromeArguments.push(...this.defaultArgs(options).filter((arg) => { + return !ignoreDefaultArgs.includes(arg); + })); + } else { + chromeArguments.push(...args); + } + if (!chromeArguments.some((argument) => { + return argument.startsWith("--remote-debugging-"); + })) { + if (pipe) { + assert(!debuggingPort, "Browser should be launched with either pipe or debugging port - not both."); + chromeArguments.push("--remote-debugging-pipe"); + } else { + chromeArguments.push(`--remote-debugging-port=${debuggingPort || 0}`); + } + } + let isTempUserDataDir = false; + let userDataDirIndex = chromeArguments.findIndex((arg) => { + return arg.startsWith("--user-data-dir"); + }); + if (userDataDirIndex < 0) { + isTempUserDataDir = true; + chromeArguments.push(`--user-data-dir=${await mkdtemp(this.getProfilePath())}`); + userDataDirIndex = chromeArguments.length - 1; + } + const userDataDir = chromeArguments[userDataDirIndex].split("=", 2)[1]; + assert(typeof userDataDir === "string", "`--user-data-dir` is malformed"); + let chromeExecutable = executablePath2; + if (!chromeExecutable) { + assert(channel || !this.puppeteer._isPuppeteerCore, `An \`executablePath\` or \`channel\` must be specified for \`puppeteer-core\``); + chromeExecutable = this.executablePath(channel, options.headless ?? true); + } + return { + executablePath: chromeExecutable, + args: chromeArguments, + isTempUserDataDir, + userDataDir + }; + } + /** + * @internal + */ + async cleanUserDataDir(path10, opts) { + if (opts.isTemp) { + try { + await rm(path10); + } catch (error) { + debugError(error); + throw error; + } + } + } + defaultArgs(options = {}) { + const userDisabledFeatures = getFeatures("--disable-features", options.args); + if (options.args && userDisabledFeatures.length > 0) { + removeMatchingFlags(options.args, "--disable-features"); + } + const turnOnExperimentalFeaturesForTesting = process.env["PUPPETEER_TEST_EXPERIMENTAL_CHROME_FEATURES"] === "true"; + const disabledFeatures = [ + "Translate", + // AcceptCHFrame disabled because of crbug.com/1348106. + "AcceptCHFrame", + "MediaRouter", + "OptimizationHints", + ...turnOnExperimentalFeaturesForTesting ? [] : [ + // https://crbug.com/1492053 + "ProcessPerSiteUpToMainFrameThreshold", + // https://github.com/puppeteer/puppeteer/issues/10715 + "IsolateSandboxedIframes" + ], + ...userDisabledFeatures + ].filter((feature) => { + return feature !== ""; + }); + const userEnabledFeatures = getFeatures("--enable-features", options.args); + if (options.args && userEnabledFeatures.length > 0) { + removeMatchingFlags(options.args, "--enable-features"); + } + const enabledFeatures = [ + "PdfOopif", + // Add features to enable by default here. + ...userEnabledFeatures + ].filter((feature) => { + return feature !== ""; + }); + const chromeArguments = [ + "--allow-pre-commit-input", + "--disable-background-networking", + "--disable-background-timer-throttling", + "--disable-backgrounding-occluded-windows", + "--disable-breakpad", + "--disable-client-side-phishing-detection", + "--disable-component-extensions-with-background-pages", + "--disable-default-apps", + "--disable-dev-shm-usage", + "--disable-extensions", + "--disable-hang-monitor", + "--disable-infobars", + "--disable-ipc-flooding-protection", + "--disable-popup-blocking", + "--disable-prompt-on-repost", + "--disable-renderer-backgrounding", + "--disable-search-engine-choice-screen", + "--disable-sync", + "--enable-automation", + "--export-tagged-pdf", + "--generate-pdf-document-outline", + "--force-color-profile=srgb", + "--metrics-recording-only", + "--no-first-run", + "--password-store=basic", + "--use-mock-keychain", + `--disable-features=${disabledFeatures.join(",")}`, + `--enable-features=${enabledFeatures.join(",")}` + ].filter((arg) => { + return arg !== ""; + }); + const { devtools = false, headless = !devtools, args = [], userDataDir } = options; + if (userDataDir) { + chromeArguments.push(`--user-data-dir=${path7.resolve(userDataDir)}`); + } + if (devtools) { + chromeArguments.push("--auto-open-devtools-for-tabs"); + } + if (headless) { + chromeArguments.push(headless === "shell" ? "--headless" : "--headless=new", "--hide-scrollbars", "--mute-audio"); + } + if (args.every((arg) => { + return arg.startsWith("-"); + })) { + chromeArguments.push("about:blank"); + } + chromeArguments.push(...args); + return chromeArguments; + } + executablePath(channel, headless) { + if (channel) { + return computeSystemExecutablePath({ + browser: Browser2.CHROME, + channel: convertPuppeteerChannelToBrowsersChannel(channel) + }); + } else { + return this.resolveExecutablePath(headless); + } + } +}; +function convertPuppeteerChannelToBrowsersChannel(channel) { + switch (channel) { + case "chrome": + return ChromeReleaseChannel.STABLE; + case "chrome-dev": + return ChromeReleaseChannel.DEV; + case "chrome-beta": + return ChromeReleaseChannel.BETA; + case "chrome-canary": + return ChromeReleaseChannel.CANARY; + } +} +function getFeatures(flag, options = []) { + return options.filter((s) => { + return s.startsWith(flag.endsWith("=") ? flag : `${flag}=`); + }).map((s) => { + return s.split(new RegExp(`${flag}=\\s*`))[1]?.trim(); + }).filter((s) => { + return s; + }); +} +function removeMatchingFlags(array, flag) { + const regex = new RegExp(`^${flag}=.*`); + let i = 0; + while (i < array.length) { + if (regex.test(array[i])) { + array.splice(i, 1); + } else { + i++; + } + } + return array; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/FirefoxLauncher.js +init_cjs_shim(); +import fs4 from "fs"; +import { rename, unlink, mkdtemp as mkdtemp2 } from "fs/promises"; +import os6 from "os"; +import path8 from "path"; +var FirefoxLauncher = class extends BrowserLauncher { + constructor(puppeteer2) { + super(puppeteer2, "firefox"); + } + static getPreferences(extraPrefsFirefox, protocol) { + return { + ...extraPrefsFirefox, + ...protocol === "webDriverBiDi" ? { + // Only enable the WebDriver BiDi protocol + "remote.active-protocols": 1 + } : { + // Do not close the window when the last tab gets closed + "browser.tabs.closeWindowWithLastTab": false, + // Prevent various error message on the console + // jest-puppeteer asserts that no error message is emitted by the console + "network.cookie.cookieBehavior": 0, + // Temporarily force disable BFCache in parent (https://bit.ly/bug-1732263) + "fission.bfcacheInParent": false, + // Only enable the CDP protocol + "remote.active-protocols": 2 + }, + // Force all web content to use a single content process. TODO: remove + // this once Firefox supports mouse event dispatch from the main frame + // context. Once this happens, webContentIsolationStrategy should only + // be set for CDP. See + // https://bugzilla.mozilla.org/show_bug.cgi?id=1773393 + "fission.webContentIsolationStrategy": 0 + }; + } + /** + * @internal + */ + async computeLaunchArguments(options = {}) { + const { ignoreDefaultArgs = false, args = [], executablePath: executablePath2, pipe = false, extraPrefsFirefox = {}, debuggingPort = null } = options; + const firefoxArguments = []; + if (!ignoreDefaultArgs) { + firefoxArguments.push(...this.defaultArgs(options)); + } else if (Array.isArray(ignoreDefaultArgs)) { + firefoxArguments.push(...this.defaultArgs(options).filter((arg) => { + return !ignoreDefaultArgs.includes(arg); + })); + } else { + firefoxArguments.push(...args); + } + if (!firefoxArguments.some((argument) => { + return argument.startsWith("--remote-debugging-"); + })) { + if (pipe) { + assert(debuggingPort === null, "Browser should be launched with either pipe or debugging port - not both."); + } + firefoxArguments.push(`--remote-debugging-port=${debuggingPort || 0}`); + } + let userDataDir; + let isTempUserDataDir = true; + const profileArgIndex = firefoxArguments.findIndex((arg) => { + return ["-profile", "--profile"].includes(arg); + }); + if (profileArgIndex !== -1) { + userDataDir = firefoxArguments[profileArgIndex + 1]; + if (!userDataDir) { + throw new Error(`Missing value for profile command line argument`); + } + isTempUserDataDir = false; + } else { + userDataDir = await mkdtemp2(this.getProfilePath()); + firefoxArguments.push("--profile"); + firefoxArguments.push(userDataDir); + } + await createProfile2(Browser2.FIREFOX, { + path: userDataDir, + preferences: FirefoxLauncher.getPreferences(extraPrefsFirefox, options.protocol) + }); + let firefoxExecutable; + if (this.puppeteer._isPuppeteerCore || executablePath2) { + assert(executablePath2, `An \`executablePath\` must be specified for \`puppeteer-core\``); + firefoxExecutable = executablePath2; + } else { + firefoxExecutable = this.executablePath(); + } + return { + isTempUserDataDir, + userDataDir, + args: firefoxArguments, + executablePath: firefoxExecutable + }; + } + /** + * @internal + */ + async cleanUserDataDir(userDataDir, opts) { + if (opts.isTemp) { + try { + await rm(userDataDir); + } catch (error) { + debugError(error); + throw error; + } + } else { + try { + const backupSuffix = ".puppeteer"; + const backupFiles = ["prefs.js", "user.js"]; + const results = await Promise.allSettled(backupFiles.map(async (file) => { + const prefsBackupPath = path8.join(userDataDir, file + backupSuffix); + if (fs4.existsSync(prefsBackupPath)) { + const prefsPath = path8.join(userDataDir, file); + await unlink(prefsPath); + await rename(prefsBackupPath, prefsPath); + } + })); + for (const result of results) { + if (result.status === "rejected") { + throw result.reason; + } + } + } catch (error) { + debugError(error); + } + } + } + executablePath() { + return this.resolveExecutablePath(); + } + defaultArgs(options = {}) { + const { devtools = false, headless = !devtools, args = [], userDataDir = null } = options; + const firefoxArguments = []; + switch (os6.platform()) { + case "darwin": + firefoxArguments.push("--foreground"); + break; + case "win32": + firefoxArguments.push("--wait-for-browser"); + break; + } + if (userDataDir) { + firefoxArguments.push("--profile"); + firefoxArguments.push(userDataDir); + } + if (headless) { + firefoxArguments.push("--headless"); + } + if (devtools) { + firefoxArguments.push("--devtools"); + } + if (args.every((arg) => { + return arg.startsWith("-"); + })) { + firefoxArguments.push("about:blank"); + } + firefoxArguments.push(...args); + return firefoxArguments; + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/PuppeteerNode.js +init_cjs_shim(); +var PuppeteerNode = class extends Puppeteer { + #_launcher; + #lastLaunchedBrowser; + /** + * @internal + */ + defaultBrowserRevision; + /** + * @internal + */ + configuration = {}; + /** + * @internal + */ + constructor(settings) { + const { configuration, ...commonSettings } = settings; + super(commonSettings); + if (configuration) { + this.configuration = configuration; + } + switch (this.configuration.defaultBrowser) { + case "firefox": + this.defaultBrowserRevision = PUPPETEER_REVISIONS.firefox; + break; + default: + this.configuration.defaultBrowser = "chrome"; + this.defaultBrowserRevision = PUPPETEER_REVISIONS.chrome; + break; + } + this.connect = this.connect.bind(this); + this.launch = this.launch.bind(this); + this.executablePath = this.executablePath.bind(this); + this.defaultArgs = this.defaultArgs.bind(this); + this.trimCache = this.trimCache.bind(this); + } + /** + * This method attaches Puppeteer to an existing browser instance. + * + * @param options - Set of configurable options to set on the browser. + * @returns Promise which resolves to browser instance. + */ + connect(options) { + return super.connect(options); + } + /** + * Launches a browser instance with given arguments and options when + * specified. + * + * When using with `puppeteer-core`, + * {@link LaunchOptions.executablePath | options.executablePath} or + * {@link LaunchOptions.channel | options.channel} must be provided. + * + * @example + * You can use {@link LaunchOptions.ignoreDefaultArgs | options.ignoreDefaultArgs} + * to filter out `--mute-audio` from default arguments: + * + * ```ts + * const browser = await puppeteer.launch({ + * ignoreDefaultArgs: ['--mute-audio'], + * }); + * ``` + * + * @remarks + * Puppeteer can also be used to control the Chrome browser, but it works best + * with the version of Chrome for Testing downloaded by default. + * There is no guarantee it will work with any other version. If Google Chrome + * (rather than Chrome for Testing) is preferred, a + * {@link https://www.google.com/chrome/browser/canary.html | Chrome Canary} + * or + * {@link https://www.chromium.org/getting-involved/dev-channel | Dev Channel} + * build is suggested. See + * {@link https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/ | this article} + * for a description of the differences between Chromium and Chrome. + * {@link https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md | This article} + * describes some differences for Linux users. See + * {@link https://developer.chrome.com/blog/chrome-for-testing/ | this doc} for the description + * of Chrome for Testing. + * + * @param options - Options to configure launching behavior. + */ + launch(options = {}) { + const { browser: product = this.defaultBrowser } = options; + this.#lastLaunchedBrowser = product; + return this.#launcher.launch(options); + } + /** + * @internal + */ + get #launcher() { + if (this.#_launcher && this.#_launcher.browser === this.lastLaunchedBrowser) { + return this.#_launcher; + } + switch (this.lastLaunchedBrowser) { + case "chrome": + this.defaultBrowserRevision = PUPPETEER_REVISIONS.chrome; + this.#_launcher = new ChromeLauncher(this); + break; + case "firefox": + this.defaultBrowserRevision = PUPPETEER_REVISIONS.firefox; + this.#_launcher = new FirefoxLauncher(this); + break; + default: + throw new Error(`Unknown product: ${this.#lastLaunchedBrowser}`); + } + return this.#_launcher; + } + /** + * The default executable path. + */ + executablePath(channel) { + return this.#launcher.executablePath(channel); + } + /** + * @internal + */ + get browserVersion() { + return this.configuration?.[this.lastLaunchedBrowser]?.version ?? this.defaultBrowserRevision; + } + /** + * The default download path for puppeteer. For puppeteer-core, this + * code should never be called as it is never defined. + * + * @internal + */ + get defaultDownloadPath() { + return this.configuration.cacheDirectory; + } + /** + * The name of the browser that was last launched. + */ + get lastLaunchedBrowser() { + return this.#lastLaunchedBrowser ?? this.defaultBrowser; + } + /** + * The name of the browser that will be launched by default. For + * `puppeteer`, this is influenced by your configuration. Otherwise, it's + * `chrome`. + */ + get defaultBrowser() { + return this.configuration.defaultBrowser ?? "chrome"; + } + /** + * @deprecated Do not use as this field as it does not take into account + * multiple browsers of different types. Use + * {@link PuppeteerNode.defaultBrowser | defaultBrowser} or + * {@link PuppeteerNode.lastLaunchedBrowser | lastLaunchedBrowser}. + * + * @returns The name of the browser that is under automation. + */ + get product() { + return this.#launcher.browser; + } + /** + * @param options - Set of configurable options to set on the browser. + * + * @returns The default flags that Chromium will be launched with. + */ + defaultArgs(options = {}) { + return this.#launcher.defaultArgs(options); + } + /** + * Removes all non-current Firefox and Chrome binaries in the cache directory + * identified by the provided Puppeteer configuration. The current browser + * version is determined by resolving PUPPETEER_REVISIONS from Puppeteer + * unless `configuration.browserRevision` is provided. + * + * @remarks + * + * Note that the method does not check if any other Puppeteer versions + * installed on the host that use the same cache directory require the + * non-current binaries. + * + * @public + */ + async trimCache() { + const platform = detectBrowserPlatform(); + if (!platform) { + throw new Error("The current platform is not supported."); + } + const cacheDir = this.configuration.cacheDirectory; + const installedBrowsers = await getInstalledBrowsers({ + cacheDir + }); + const puppeteerBrowsers = [ + { + product: "chrome", + browser: Browser2.CHROME, + currentBuildId: "" + }, + { + product: "firefox", + browser: Browser2.FIREFOX, + currentBuildId: "" + } + ]; + for (const item of puppeteerBrowsers) { + const tag = this.configuration?.[item.product]?.version ?? PUPPETEER_REVISIONS[item.product]; + item.currentBuildId = await resolveBuildId4(item.browser, platform, tag); + } + const currentBrowserBuilds = new Set(puppeteerBrowsers.map((browser) => { + return `${browser.browser}_${browser.currentBuildId}`; + })); + const currentBrowsers = new Set(puppeteerBrowsers.map((browser) => { + return browser.browser; + })); + for (const installedBrowser of installedBrowsers) { + if (!currentBrowsers.has(installedBrowser.browser)) { + continue; + } + if (currentBrowserBuilds.has(`${installedBrowser.browser}_${installedBrowser.buildId}`)) { + continue; + } + await uninstall({ + browser: installedBrowser.browser, + platform, + cacheDir, + buildId: installedBrowser.buildId + }); + } + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/ScreenRecorder.js +init_cjs_shim(); +var import_debug5 = __toESM(require_src(), 1); +import { spawn, spawnSync } from "child_process"; +import { PassThrough } from "stream"; +var __runInitializers4 = 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 __esDecorate4 = 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 __setFunctionName2 = 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 }); +}; +var CRF_VALUE = 30; +var DEFAULT_FPS = 30; +var debugFfmpeg = (0, import_debug5.default)("puppeteer:ffmpeg"); +var ScreenRecorder = (() => { + let _classSuper = PassThrough; + let _instanceExtraInitializers = []; + let _private_writeFrame_decorators; + let _private_writeFrame_descriptor; + let _stop_decorators; + return class ScreenRecorder extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + __esDecorate4(this, _private_writeFrame_descriptor = { value: __setFunctionName2(async function(buffer) { + const error = await new Promise((resolve5) => { + this.#process.stdin.write(buffer, resolve5); + }); + if (error) { + console.log(`ffmpeg failed to write: ${error.message}.`); + } + }, "#writeFrame") }, _private_writeFrame_decorators, { kind: "method", name: "#writeFrame", static: false, private: true, access: { has: (obj) => #writeFrame in obj, get: (obj) => obj.#writeFrame }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate4(this, null, _stop_decorators, { kind: "method", name: "stop", static: false, private: false, access: { has: (obj) => "stop" in obj, get: (obj) => obj.stop }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + #page = __runInitializers4(this, _instanceExtraInitializers); + #process; + #controller = new AbortController(); + #lastFrame; + /** + * @internal + */ + constructor(page, width, height, { speed, scale, crop, format: format3, path: path10 } = {}) { + super({ allowHalfOpen: false }); + path10 ??= "ffmpeg"; + const { error } = spawnSync(path10); + if (error) { + throw error; + } + this.#process = spawn( + path10, + // See https://trac.ffmpeg.org/wiki/Encode/VP9 for more information on flags. + [ + ["-loglevel", "error"], + // Reduces general buffering. + ["-avioflags", "direct"], + // Reduces initial buffering while analyzing input fps and other stats. + [ + "-fpsprobesize", + "0", + "-probesize", + "32", + "-analyzeduration", + "0", + "-fflags", + "nobuffer" + ], + // Forces input to be read from standard input, and forces png input + // image format. + ["-f", "image2pipe", "-c:v", "png", "-i", "pipe:0"], + // Overwrite output and no audio. + ["-y", "-an"], + // This drastically reduces stalling when cpu is overbooked. By default + // VP9 tries to use all available threads? + ["-threads", "1"], + // Specifies the frame rate we are giving ffmpeg. + ["-framerate", `${DEFAULT_FPS}`], + // Specifies the encoding and format we are using. + this.#getFormatArgs(format3 ?? "webm"), + // Disable bitrate. + ["-b:v", "0"], + // Filters to ensure the images are piped correctly. + [ + "-vf", + `${speed ? `setpts=${1 / speed}*PTS,` : ""}crop='min(${width},iw):min(${height},ih):0:0',pad=${width}:${height}:0:0${crop ? `,crop=${crop.width}:${crop.height}:${crop.x}:${crop.y}` : ""}${scale ? `,scale=iw*${scale}:-1` : ""}` + ], + "pipe:1" + ].flat(), + { stdio: ["pipe", "pipe", "pipe"] } + ); + this.#process.stdout.pipe(this); + this.#process.stderr.on("data", (data) => { + debugFfmpeg(data.toString("utf8")); + }); + this.#page = page; + const { client } = this.#page.mainFrame(); + client.once(CDPSessionEvent.Disconnected, () => { + void this.stop().catch(debugError); + }); + this.#lastFrame = lastValueFrom(fromEmitterEvent(client, "Page.screencastFrame").pipe(tap((event) => { + void client.send("Page.screencastFrameAck", { + sessionId: event.sessionId + }); + }), filter((event) => { + return event.metadata.timestamp !== void 0; + }), map((event) => { + return { + buffer: Buffer.from(event.data, "base64"), + timestamp: event.metadata.timestamp + }; + }), bufferCount(2, 1), concatMap(([{ timestamp: previousTimestamp, buffer }, { timestamp }]) => { + return from(Array(Math.round(DEFAULT_FPS * Math.max(timestamp - previousTimestamp, 0))).fill(buffer)); + }), map((buffer) => { + void this.#writeFrame(buffer); + return [buffer, performance.now()]; + }), takeUntil(fromEvent(this.#controller.signal, "abort"))), { defaultValue: [Buffer.from([]), performance.now()] }); + } + #getFormatArgs(format3) { + switch (format3) { + case "webm": + return [ + // Sets the codec to use. + ["-c:v", "vp9"], + // Sets the format + ["-f", "webm"], + // Sets the quality. Lower the better. + ["-crf", `${CRF_VALUE}`], + // Sets the quality and how efficient the compression will be. + ["-deadline", "realtime", "-cpu-used", "8"] + ].flat(); + case "gif": + return [ + // Sets the frame rate and uses a custom palette generated from the + // input. + [ + "-vf", + "fps=5,split[s0][s1];[s0]palettegen=stats_mode=diff[p];[s1][p]paletteuse" + ], + // Sets the format + ["-f", "gif"] + ].flat(); + } + } + get #writeFrame() { + return _private_writeFrame_descriptor.value; + } + /** + * Stops the recorder. + * + * @public + */ + async stop() { + if (this.#controller.signal.aborted) { + return; + } + await this.#page._stopScreencast().catch(debugError); + this.#controller.abort(); + const [buffer, timestamp] = await this.#lastFrame; + await Promise.all(Array(Math.max(1, Math.round(DEFAULT_FPS * (performance.now() - timestamp) / 1e3))).fill(buffer).map(this.#writeFrame.bind(this))); + this.#process.stdin.end(); + await new Promise((resolve5) => { + this.#process.once("close", resolve5); + }); + } + /** + * @internal + */ + async [(_private_writeFrame_decorators = [guarded()], _stop_decorators = [guarded()], asyncDisposeSymbol)]() { + await this.stop(); + } + }; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/puppeteer-core.js +import fs5 from "fs"; +import path9 from "path"; +environment.value = { + fs: fs5, + path: path9, + ScreenRecorder +}; +var puppeteer = new PuppeteerNode({ + isPuppeteerCore: true +}); +var { + /** + * @public + */ + connect, + /** + * @public + */ + defaultArgs, + /** + * @public + */ + executablePath, + /** + * @public + */ + launch: launch2 +} = puppeteer; +var puppeteer_core_default = puppeteer; + +export { + puppeteer_core_default, + assert2 as assert +}; +/*! Bundled license information: + +assertion-error/index.js: + (*! + * assertion-error + * Copyright(c) 2013 Jake Luer + * MIT Licensed + *) + (*! + * Return a function that will copy properties from + * one object to another excluding any originally + * listed. Returned function will create a new `{}`. + * + * @param {String} excluded properties ... + * @return {Function} + *) + (*! + * Primary Exports + *) + (*! + * Inherit from Error.prototype + *) + (*! + * Statically set name + *) + (*! + * Ensure correct constructor + *) + +chai/lib/chai/utils/flag.js: + (*! + * Chai - flag utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/test.js: + (*! + * Chai - test utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + (*! + * Module dependencies + *) + +chai/lib/chai/utils/expectTypes.js: + (*! + * Chai - expectTypes utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/getActual.js: + (*! + * Chai - getActual utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/objDisplay.js: + (*! + * Chai - flag utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + (*! + * Module dependencies + *) + +chai/lib/chai/utils/getMessage.js: + (*! + * Chai - message composition utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + (*! + * Module dependencies + *) + +chai/lib/chai/utils/transferFlags.js: + (*! + * Chai - transferFlags utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +deep-eql/index.js: + (*! + * deep-eql + * Copyright(c) 2013 Jake Luer + * MIT Licensed + *) + (*! + * Check to see if the MemoizeMap has recorded a result of the two operands + * + * @param {Mixed} leftHandOperand + * @param {Mixed} rightHandOperand + * @param {MemoizeMap} memoizeMap + * @returns {Boolean|null} result + *) + (*! + * Set the result of the equality into the MemoizeMap + * + * @param {Mixed} leftHandOperand + * @param {Mixed} rightHandOperand + * @param {MemoizeMap} memoizeMap + * @param {Boolean} result + *) + (*! + * Primary Export + *) + (*! + * The main logic of the `deepEqual` function. + * + * @param {Mixed} leftHandOperand + * @param {Mixed} rightHandOperand + * @param {Object} [options] (optional) Additional options + * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality. + * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of + complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular + references to blow the stack. + * @return {Boolean} equal match + *) + (*! + * Compare two Regular Expressions for equality. + * + * @param {RegExp} leftHandOperand + * @param {RegExp} rightHandOperand + * @return {Boolean} result + *) + (*! + * Compare two Sets/Maps for equality. Faster than other equality functions. + * + * @param {Set} leftHandOperand + * @param {Set} rightHandOperand + * @param {Object} [options] (Optional) + * @return {Boolean} result + *) + (*! + * Simple equality for flat iterable objects such as Arrays, TypedArrays or Node.js buffers. + * + * @param {Iterable} leftHandOperand + * @param {Iterable} rightHandOperand + * @param {Object} [options] (Optional) + * @return {Boolean} result + *) + (*! + * Simple equality for generator objects such as those returned by generator functions. + * + * @param {Iterable} leftHandOperand + * @param {Iterable} rightHandOperand + * @param {Object} [options] (Optional) + * @return {Boolean} result + *) + (*! + * Determine if the given object has an @@iterator function. + * + * @param {Object} target + * @return {Boolean} `true` if the object has an @@iterator function. + *) + (*! + * Gets all iterator entries from the given Object. If the Object has no @@iterator function, returns an empty array. + * This will consume the iterator - which could have side effects depending on the @@iterator implementation. + * + * @param {Object} target + * @returns {Array} an array of entries from the @@iterator function + *) + (*! + * Gets all entries from a Generator. This will consume the generator - which could have side effects. + * + * @param {Generator} target + * @returns {Array} an array of entries from the Generator. + *) + (*! + * Gets all own and inherited enumerable keys from a target. + * + * @param {Object} target + * @returns {Array} an array of own and inherited enumerable keys from the target. + *) + (*! + * Determines if two objects have matching values, given a set of keys. Defers to deepEqual for the equality check of + * each key. If any value of the given key is not equal, the function will return false (early). + * + * @param {Mixed} leftHandOperand + * @param {Mixed} rightHandOperand + * @param {Array} keys An array of keys to compare the values of leftHandOperand and rightHandOperand against + * @param {Object} [options] (Optional) + * @return {Boolean} result + *) + (*! + * Recursively check the equality of two Objects. Once basic sameness has been established it will defer to `deepEqual` + * for each enumerable key in the object. + * + * @param {Mixed} leftHandOperand + * @param {Mixed} rightHandOperand + * @param {Object} [options] (Optional) + * @return {Boolean} result + *) + (*! + * Returns true if the argument is a primitive. + * + * This intentionally returns true for all objects that can be compared by reference, + * including functions and symbols. + * + * @param {Mixed} value + * @return {Boolean} result + *) + +chai/lib/chai/utils/isProxyEnabled.js: + (*! + * Chai - isProxyEnabled helper + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/addProperty.js: + (*! + * Chai - addProperty utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/addLengthGuard.js: + (*! + * Chai - addLengthGuard utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/getProperties.js: + (*! + * Chai - getProperties utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/proxify.js: + (*! + * Chai - proxify utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/addMethod.js: + (*! + * Chai - addMethod utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/overwriteProperty.js: + (*! + * Chai - overwriteProperty utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/overwriteMethod.js: + (*! + * Chai - overwriteMethod utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/addChainableMethod.js: + (*! + * Chai - addChainingMethod utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + (*! + * Module dependencies + *) + (*! + * Module variables + *) + +chai/lib/chai/utils/overwriteChainableMethod.js: + (*! + * Chai - overwriteChainableMethod utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/compareByInspect.js: + (*! + * Chai - compareByInspect utility + * Copyright(c) 2011-2016 Jake Luer + * MIT Licensed + *) + (*! + * Module dependencies + *) + +chai/lib/chai/utils/getOwnEnumerablePropertySymbols.js: + (*! + * Chai - getOwnEnumerablePropertySymbols utility + * Copyright(c) 2011-2016 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/utils/getOwnEnumerableProperties.js: + (*! + * Chai - getOwnEnumerableProperties utility + * Copyright(c) 2011-2016 Jake Luer + * MIT Licensed + *) + (*! + * Module dependencies + *) + +chai/lib/chai/utils/isNaN.js: + (*! + * Chai - isNaN utility + * Copyright(c) 2012-2015 Sakthipriyan Vairamani + * MIT Licensed + *) + +chai/lib/chai/utils/index.js: + (*! + * chai + * Copyright(c) 2011 Jake Luer + * MIT Licensed + *) + (*! + * Dependencies that are used for multiple exports are required here only once + *) + (*! + * test utility + *) + (*! + * type utility + *) + (*! + * expectTypes utility + *) + (*! + * message utility + *) + (*! + * actual utility + *) + (*! + * Inspect util + *) + (*! + * Object Display util + *) + (*! + * Flag utility + *) + (*! + * Flag transferring utility + *) + (*! + * Deep equal utility + *) + (*! + * Deep path info + *) + (*! + * Check if a property exists + *) + (*! + * Function name + *) + (*! + * add Property + *) + (*! + * add Method + *) + (*! + * overwrite Property + *) + (*! + * overwrite Method + *) + (*! + * Add a chainable method + *) + (*! + * Overwrite chainable method + *) + (*! + * Compare by inspect method + *) + (*! + * Get own enumerable property symbols method + *) + (*! + * Get own enumerable properties method + *) + (*! + * Checks error against a given set of criteria + *) + (*! + * Proxify util + *) + (*! + * addLengthGuard util + *) + (*! + * isProxyEnabled helper + *) + (*! + * isNaN method + *) + (*! + * getOperator method + *) + +chai/lib/chai/assertion.js: + (*! + * chai + * http://chaijs.com + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + *) + (*! + * Module dependencies. + *) + (*! + * Module export. + *) + (*! + * Assertion Constructor + * + * Creates object for chaining. + * + * `Assertion` objects contain metadata in the form of flags. Three flags can + * be assigned during instantiation by passing arguments to this constructor: + * + * - `object`: This flag contains the target of the assertion. For example, in + * the assertion `expect(numKittens).to.equal(7);`, the `object` flag will + * contain `numKittens` so that the `equal` assertion can reference it when + * needed. + * + * - `message`: This flag contains an optional custom error message to be + * prepended to the error message that's generated by the assertion when it + * fails. + * + * - `ssfi`: This flag stands for "start stack function indicator". It + * contains a function reference that serves as the starting point for + * removing frames from the stack trace of the error that's created by the + * assertion when it fails. The goal is to provide a cleaner stack trace to + * end users by removing Chai's internal functions. Note that it only works + * in environments that support `Error.captureStackTrace`, and only when + * `Chai.config.includeStack` hasn't been set to `false`. + * + * - `lockSsfi`: This flag controls whether or not the given `ssfi` flag + * should retain its current value, even as assertions are chained off of + * this object. This is usually set to `true` when creating a new assertion + * from within another assertion. It's also temporarily set to `true` before + * an overwritten assertion gets called by the overwriting assertion. + * + * - `eql`: This flag contains the deepEqual function to be used by the assertion. + * + * @param {Mixed} obj target of the assertion + * @param {String} msg (optional) custom error message + * @param {Function} ssfi (optional) starting point for removing stack frames + * @param {Boolean} lockSsfi (optional) whether or not the ssfi flag is locked + * @api private + *) + (*! + * ### ._obj + * + * Quick reference to stored `actual` value for plugin developers. + * + * @api private + *) + +chai/lib/chai/core/assertions.js: + (*! + * chai + * http://chaijs.com + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/interface/expect.js: + (*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/interface/should.js: + (*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + *) + +chai/lib/chai/interface/assert.js: + (*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + *) + (*! + * Chai dependencies. + *) + (*! + * Module export. + *) + (*! + * ### .ifError(object) + * + * Asserts if value is not a false value, and throws if it is a true value. + * This is added to allow for chai to be a drop-in replacement for Node's + * assert class. + * + * var err = new Error('I am a custom error'); + * assert.ifError(err); // Rethrows err! + * + * @name ifError + * @param {Object} object + * @namespace Assert + * @api public + *) + (*! + * Aliases. + *) + +chai/lib/chai.js: + (*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + *) + (*! + * Chai version + *) + (*! + * Assertion Error + *) + (*! + * Utils for plugins (not exported) + *) + (*! + * Utility Functions + *) + (*! + * Configuration + *) + (*! + * Primary `Assertion` prototype + *) + (*! + * Core Assertions + *) + (*! + * Expect interface + *) + (*! + * Should interface + *) + (*! + * Assert interface + *) + +progress/lib/node-progress.js: + (*! + * node-progress + * Copyright(c) 2011 TJ Holowaychuk + * MIT Licensed + *) + +puppeteer-core/lib/esm/puppeteer/api/api.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/Binding.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/BrowserContext.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/CDPSession.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/common/FileChooser.js: + (** + * @license + * Copyright 2020 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/common/NetworkManagerEvents.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/Connection.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/Dialog.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/FirefoxTargetManager.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/CdpPreloadScript.js: + (** + * @license + * Copyright 2024 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/DeviceRequestPrompt.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/utils.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/JSHandle.js: + (** + * @license + * Copyright 2019 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/ElementHandle.js: + (** + * @license + * Copyright 2019 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/ExecutionContext.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/FrameManagerEvents.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/IsolatedWorld.js: + (** + * @license + * Copyright 2019 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/IsolatedWorlds.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/LifecycleWatcher.js: + (** + * @license + * Copyright 2019 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/Frame.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/FrameTree.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/NetworkEventManager.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/NetworkManager.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/FrameManager.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/common/USKeyboardLayout.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/Input.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/Page.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/Target.js: + (** + * @license + * Copyright 2019 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/ChromeTargetManager.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/Browser.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/BrowserConnector.js: + (** + * @license + * Copyright 2020 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/PredefinedNetworkConditions.js: + (** + * @license + * Copyright 2021 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/TargetManager.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/cdp/cdp.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/common/Device.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/bidi/BrowserConnector.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/common/BrowserConnector.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/common/Puppeteer.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/common/TaskQueue.js: + (** + * @license + * Copyright 2020 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/common/common.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/revisions.js: + (** + * @license + * Copyright 2020 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/util/util.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/index-browser.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/browser-data/types.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/httpUtil.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/browser-data/chrome.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/browser-data/chrome-headless-shell.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/browser-data/chromedriver.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/browser-data/chromium.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/browser-data/firefox.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/browser-data/browser-data.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/detectPlatform.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/Cache.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/debug.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/launch.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/fileUtil.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/install.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +yargs-parser/build/lib/string-utils.js: + (** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + *) + +yargs-parser/build/lib/tokenize-arg-string.js: + (** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + *) + +yargs-parser/build/lib/yargs-parser-types.js: + (** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + *) + +yargs-parser/build/lib/yargs-parser.js: + (** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + *) + +yargs-parser/build/lib/index.js: + (** + * @fileoverview Main entrypoint for libraries using yargs-parser in Node.js + * CJS and ESM environments. + * + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + *) + +@puppeteer/browsers/lib/esm/CLI.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +@puppeteer/browsers/lib/esm/main.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/node/BrowserLauncher.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/node/util/fs.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/node/ChromeLauncher.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/node/FirefoxLauncher.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/node/PuppeteerNode.js: + (** + * @license + * Copyright 2020 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/node/ScreenRecorder.js: + (** + * @license + * Copyright 2023 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/node/node.js: + (** + * @license + * Copyright 2022 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/index.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) + +puppeteer-core/lib/esm/puppeteer/puppeteer-core.js: + (** + * @license + * Copyright 2017 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) +*/ diff --git a/docs/node/chunk-PJC2V65J.mjs b/docs/node/chunk-PJC2V65J.mjs new file mode 100644 index 00000000..1acc5f29 --- /dev/null +++ b/docs/node/chunk-PJC2V65J.mjs @@ -0,0 +1,3790 @@ +import { createRequire } from 'module';const require = createRequire(import.meta.url); +import { + packageVersion +} from "./chunk-VDOS7AVZ.mjs"; +import { + __commonJS, + __require, + __toESM, + init_cjs_shim +} from "./chunk-THMF2HPO.mjs"; + +// ../testeranto/node_modules/ws/lib/stream.js +var require_stream = __commonJS({ + "../testeranto/node_modules/ws/lib/stream.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { Duplex } = __require("stream"); + function emitClose(stream) { + stream.emit("close"); + } + function duplexOnEnd() { + if (!this.destroyed && this._writableState.finished) { + this.destroy(); + } + } + function duplexOnError(err) { + this.removeListener("error", duplexOnError); + this.destroy(); + if (this.listenerCount("error") === 0) { + this.emit("error", err); + } + } + function createWebSocketStream2(ws, options) { + let terminateOnDestroy = true; + const duplex = new Duplex({ + ...options, + autoDestroy: false, + emitClose: false, + objectMode: false, + writableObjectMode: false + }); + ws.on("message", function message(msg, isBinary) { + const data = !isBinary && duplex._readableState.objectMode ? msg.toString() : msg; + if (!duplex.push(data)) + ws.pause(); + }); + ws.once("error", function error(err) { + if (duplex.destroyed) + return; + terminateOnDestroy = false; + duplex.destroy(err); + }); + ws.once("close", function close() { + if (duplex.destroyed) + return; + duplex.push(null); + }); + duplex._destroy = function(err, callback) { + if (ws.readyState === ws.CLOSED) { + callback(err); + process.nextTick(emitClose, duplex); + return; + } + let called = false; + ws.once("error", function error(err2) { + called = true; + callback(err2); + }); + ws.once("close", function close() { + if (!called) + callback(err); + process.nextTick(emitClose, duplex); + }); + if (terminateOnDestroy) + ws.terminate(); + }; + duplex._final = function(callback) { + if (ws.readyState === ws.CONNECTING) { + ws.once("open", function open() { + duplex._final(callback); + }); + return; + } + if (ws._socket === null) + return; + if (ws._socket._writableState.finished) { + callback(); + if (duplex._readableState.endEmitted) + duplex.destroy(); + } else { + ws._socket.once("finish", function finish() { + callback(); + }); + ws.close(); + } + }; + duplex._read = function() { + if (ws.isPaused) + ws.resume(); + }; + duplex._write = function(chunk, encoding, callback) { + if (ws.readyState === ws.CONNECTING) { + ws.once("open", function open() { + duplex._write(chunk, encoding, callback); + }); + return; + } + ws.send(chunk, callback); + }; + duplex.on("end", duplexOnEnd); + duplex.on("error", duplexOnError); + return duplex; + } + module.exports = createWebSocketStream2; + } +}); + +// ../testeranto/node_modules/ws/lib/constants.js +var require_constants = __commonJS({ + "../testeranto/node_modules/ws/lib/constants.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"]; + var hasBlob = typeof Blob !== "undefined"; + if (hasBlob) + BINARY_TYPES.push("blob"); + module.exports = { + BINARY_TYPES, + EMPTY_BUFFER: Buffer.alloc(0), + GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", + hasBlob, + kForOnEventAttribute: Symbol("kIsForOnEventAttribute"), + kListener: Symbol("kListener"), + kStatusCode: Symbol("status-code"), + kWebSocket: Symbol("websocket"), + NOOP: () => { + } + }; + } +}); + +// ../testeranto/node_modules/ws/lib/buffer-util.js +var require_buffer_util = __commonJS({ + "../testeranto/node_modules/ws/lib/buffer-util.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { EMPTY_BUFFER } = require_constants(); + var FastBuffer = Buffer[Symbol.species]; + function concat(list, totalLength) { + if (list.length === 0) + return EMPTY_BUFFER; + if (list.length === 1) + return list[0]; + const target = Buffer.allocUnsafe(totalLength); + let offset = 0; + for (let i = 0; i < list.length; i++) { + const buf = list[i]; + target.set(buf, offset); + offset += buf.length; + } + if (offset < totalLength) { + return new FastBuffer(target.buffer, target.byteOffset, offset); + } + return target; + } + function _mask(source, mask, output, offset, length) { + for (let i = 0; i < length; i++) { + output[offset + i] = source[i] ^ mask[i & 3]; + } + } + function _unmask(buffer, mask) { + for (let i = 0; i < buffer.length; i++) { + buffer[i] ^= mask[i & 3]; + } + } + function toArrayBuffer(buf) { + if (buf.length === buf.buffer.byteLength) { + return buf.buffer; + } + return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length); + } + function toBuffer(data) { + toBuffer.readOnly = true; + if (Buffer.isBuffer(data)) + return data; + let buf; + if (data instanceof ArrayBuffer) { + buf = new FastBuffer(data); + } else if (ArrayBuffer.isView(data)) { + buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength); + } else { + buf = Buffer.from(data); + toBuffer.readOnly = false; + } + return buf; + } + module.exports = { + concat, + mask: _mask, + toArrayBuffer, + toBuffer, + unmask: _unmask + }; + if (!process.env.WS_NO_BUFFER_UTIL) { + try { + const bufferUtil = __require("bufferutil"); + module.exports.mask = function(source, mask, output, offset, length) { + if (length < 48) + _mask(source, mask, output, offset, length); + else + bufferUtil.mask(source, mask, output, offset, length); + }; + module.exports.unmask = function(buffer, mask) { + if (buffer.length < 32) + _unmask(buffer, mask); + else + bufferUtil.unmask(buffer, mask); + }; + } catch (e) { + } + } + } +}); + +// ../testeranto/node_modules/ws/lib/limiter.js +var require_limiter = __commonJS({ + "../testeranto/node_modules/ws/lib/limiter.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var kDone = Symbol("kDone"); + var kRun = Symbol("kRun"); + var Limiter = class { + /** + * Creates a new `Limiter`. + * + * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed + * to run concurrently + */ + constructor(concurrency) { + this[kDone] = () => { + this.pending--; + this[kRun](); + }; + this.concurrency = concurrency || Infinity; + this.jobs = []; + this.pending = 0; + } + /** + * Adds a job to the queue. + * + * @param {Function} job The job to run + * @public + */ + add(job) { + this.jobs.push(job); + this[kRun](); + } + /** + * Removes a job from the queue and runs it if possible. + * + * @private + */ + [kRun]() { + if (this.pending === this.concurrency) + return; + if (this.jobs.length) { + const job = this.jobs.shift(); + this.pending++; + job(this[kDone]); + } + } + }; + module.exports = Limiter; + } +}); + +// ../testeranto/node_modules/ws/lib/permessage-deflate.js +var require_permessage_deflate = __commonJS({ + "../testeranto/node_modules/ws/lib/permessage-deflate.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var zlib = __require("zlib"); + var bufferUtil = require_buffer_util(); + var Limiter = require_limiter(); + var { kStatusCode } = require_constants(); + var FastBuffer = Buffer[Symbol.species]; + var TRAILER = Buffer.from([0, 0, 255, 255]); + var kPerMessageDeflate = Symbol("permessage-deflate"); + var kTotalLength = Symbol("total-length"); + var kCallback = Symbol("callback"); + var kBuffers = Symbol("buffers"); + var kError = Symbol("error"); + var zlibLimiter; + var PerMessageDeflate = class { + /** + * Creates a PerMessageDeflate instance. + * + * @param {Object} [options] Configuration options + * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support + * for, or request, a custom client window size + * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/ + * acknowledge disabling of client context takeover + * @param {Number} [options.concurrencyLimit=10] The number of concurrent + * calls to zlib + * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the + * use of a custom server window size + * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept + * disabling of server context takeover + * @param {Number} [options.threshold=1024] Size (in bytes) below which + * messages should not be compressed if context takeover is disabled + * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on + * deflate + * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on + * inflate + * @param {Boolean} [isServer=false] Create the instance in either server or + * client mode + * @param {Number} [maxPayload=0] The maximum allowed message length + */ + constructor(options, isServer, maxPayload) { + this._maxPayload = maxPayload | 0; + this._options = options || {}; + this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024; + this._isServer = !!isServer; + this._deflate = null; + this._inflate = null; + this.params = null; + if (!zlibLimiter) { + const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10; + zlibLimiter = new Limiter(concurrency); + } + } + /** + * @type {String} + */ + static get extensionName() { + return "permessage-deflate"; + } + /** + * Create an extension negotiation offer. + * + * @return {Object} Extension parameters + * @public + */ + offer() { + const params = {}; + if (this._options.serverNoContextTakeover) { + params.server_no_context_takeover = true; + } + if (this._options.clientNoContextTakeover) { + params.client_no_context_takeover = true; + } + if (this._options.serverMaxWindowBits) { + params.server_max_window_bits = this._options.serverMaxWindowBits; + } + if (this._options.clientMaxWindowBits) { + params.client_max_window_bits = this._options.clientMaxWindowBits; + } else if (this._options.clientMaxWindowBits == null) { + params.client_max_window_bits = true; + } + return params; + } + /** + * Accept an extension negotiation offer/response. + * + * @param {Array} configurations The extension negotiation offers/reponse + * @return {Object} Accepted configuration + * @public + */ + accept(configurations) { + configurations = this.normalizeParams(configurations); + this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations); + return this.params; + } + /** + * Releases all resources used by the extension. + * + * @public + */ + cleanup() { + if (this._inflate) { + this._inflate.close(); + this._inflate = null; + } + if (this._deflate) { + const callback = this._deflate[kCallback]; + this._deflate.close(); + this._deflate = null; + if (callback) { + callback( + new Error( + "The deflate stream was closed while data was being processed" + ) + ); + } + } + } + /** + * Accept an extension negotiation offer. + * + * @param {Array} offers The extension negotiation offers + * @return {Object} Accepted configuration + * @private + */ + acceptAsServer(offers) { + const opts = this._options; + const accepted = offers.find((params) => { + if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) { + return false; + } + return true; + }); + if (!accepted) { + throw new Error("None of the extension offers can be accepted"); + } + if (opts.serverNoContextTakeover) { + accepted.server_no_context_takeover = true; + } + if (opts.clientNoContextTakeover) { + accepted.client_no_context_takeover = true; + } + if (typeof opts.serverMaxWindowBits === "number") { + accepted.server_max_window_bits = opts.serverMaxWindowBits; + } + if (typeof opts.clientMaxWindowBits === "number") { + accepted.client_max_window_bits = opts.clientMaxWindowBits; + } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) { + delete accepted.client_max_window_bits; + } + return accepted; + } + /** + * Accept the extension negotiation response. + * + * @param {Array} response The extension negotiation response + * @return {Object} Accepted configuration + * @private + */ + acceptAsClient(response) { + const params = response[0]; + if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) { + throw new Error('Unexpected parameter "client_no_context_takeover"'); + } + if (!params.client_max_window_bits) { + if (typeof this._options.clientMaxWindowBits === "number") { + params.client_max_window_bits = this._options.clientMaxWindowBits; + } + } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) { + throw new Error( + 'Unexpected or invalid parameter "client_max_window_bits"' + ); + } + return params; + } + /** + * Normalize parameters. + * + * @param {Array} configurations The extension negotiation offers/reponse + * @return {Array} The offers/response with normalized parameters + * @private + */ + normalizeParams(configurations) { + configurations.forEach((params) => { + Object.keys(params).forEach((key) => { + let value = params[key]; + if (value.length > 1) { + throw new Error(`Parameter "${key}" must have only a single value`); + } + value = value[0]; + if (key === "client_max_window_bits") { + if (value !== true) { + const num = +value; + if (!Number.isInteger(num) || num < 8 || num > 15) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + value = num; + } else if (!this._isServer) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + } else if (key === "server_max_window_bits") { + const num = +value; + if (!Number.isInteger(num) || num < 8 || num > 15) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + value = num; + } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") { + if (value !== true) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + } else { + throw new Error(`Unknown parameter "${key}"`); + } + params[key] = value; + }); + }); + return configurations; + } + /** + * Decompress data. Concurrency limited. + * + * @param {Buffer} data Compressed data + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @public + */ + decompress(data, fin, callback) { + zlibLimiter.add((done) => { + this._decompress(data, fin, (err, result) => { + done(); + callback(err, result); + }); + }); + } + /** + * Compress data. Concurrency limited. + * + * @param {(Buffer|String)} data Data to compress + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @public + */ + compress(data, fin, callback) { + zlibLimiter.add((done) => { + this._compress(data, fin, (err, result) => { + done(); + callback(err, result); + }); + }); + } + /** + * Decompress data. + * + * @param {Buffer} data Compressed data + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @private + */ + _decompress(data, fin, callback) { + const endpoint = this._isServer ? "client" : "server"; + if (!this._inflate) { + const key = `${endpoint}_max_window_bits`; + const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key]; + this._inflate = zlib.createInflateRaw({ + ...this._options.zlibInflateOptions, + windowBits + }); + this._inflate[kPerMessageDeflate] = this; + this._inflate[kTotalLength] = 0; + this._inflate[kBuffers] = []; + this._inflate.on("error", inflateOnError); + this._inflate.on("data", inflateOnData); + } + this._inflate[kCallback] = callback; + this._inflate.write(data); + if (fin) + this._inflate.write(TRAILER); + this._inflate.flush(() => { + const err = this._inflate[kError]; + if (err) { + this._inflate.close(); + this._inflate = null; + callback(err); + return; + } + const data2 = bufferUtil.concat( + this._inflate[kBuffers], + this._inflate[kTotalLength] + ); + if (this._inflate._readableState.endEmitted) { + this._inflate.close(); + this._inflate = null; + } else { + this._inflate[kTotalLength] = 0; + this._inflate[kBuffers] = []; + if (fin && this.params[`${endpoint}_no_context_takeover`]) { + this._inflate.reset(); + } + } + callback(null, data2); + }); + } + /** + * Compress data. + * + * @param {(Buffer|String)} data Data to compress + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @private + */ + _compress(data, fin, callback) { + const endpoint = this._isServer ? "server" : "client"; + if (!this._deflate) { + const key = `${endpoint}_max_window_bits`; + const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key]; + this._deflate = zlib.createDeflateRaw({ + ...this._options.zlibDeflateOptions, + windowBits + }); + this._deflate[kTotalLength] = 0; + this._deflate[kBuffers] = []; + this._deflate.on("data", deflateOnData); + } + this._deflate[kCallback] = callback; + this._deflate.write(data); + this._deflate.flush(zlib.Z_SYNC_FLUSH, () => { + if (!this._deflate) { + return; + } + let data2 = bufferUtil.concat( + this._deflate[kBuffers], + this._deflate[kTotalLength] + ); + if (fin) { + data2 = new FastBuffer(data2.buffer, data2.byteOffset, data2.length - 4); + } + this._deflate[kCallback] = null; + this._deflate[kTotalLength] = 0; + this._deflate[kBuffers] = []; + if (fin && this.params[`${endpoint}_no_context_takeover`]) { + this._deflate.reset(); + } + callback(null, data2); + }); + } + }; + module.exports = PerMessageDeflate; + function deflateOnData(chunk) { + this[kBuffers].push(chunk); + this[kTotalLength] += chunk.length; + } + function inflateOnData(chunk) { + this[kTotalLength] += chunk.length; + if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) { + this[kBuffers].push(chunk); + return; + } + this[kError] = new RangeError("Max payload size exceeded"); + this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"; + this[kError][kStatusCode] = 1009; + this.removeListener("data", inflateOnData); + this.reset(); + } + function inflateOnError(err) { + this[kPerMessageDeflate]._inflate = null; + err[kStatusCode] = 1007; + this[kCallback](err); + } + } +}); + +// ../testeranto/node_modules/ws/lib/validation.js +var require_validation = __commonJS({ + "../testeranto/node_modules/ws/lib/validation.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { isUtf8 } = __require("buffer"); + var { hasBlob } = require_constants(); + var tokenChars = [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + // 0 - 15 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + // 16 - 31 + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + // 32 - 47 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + // 48 - 63 + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + // 64 - 79 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + // 80 - 95 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + // 96 - 111 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0 + // 112 - 127 + ]; + function isValidStatusCode(code) { + return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999; + } + function _isValidUTF8(buf) { + const len = buf.length; + let i = 0; + while (i < len) { + if ((buf[i] & 128) === 0) { + i++; + } else if ((buf[i] & 224) === 192) { + if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) { + return false; + } + i += 2; + } else if ((buf[i] & 240) === 224) { + if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || // Overlong + buf[i] === 237 && (buf[i + 1] & 224) === 160) { + return false; + } + i += 3; + } else if ((buf[i] & 248) === 240) { + if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || // Overlong + buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) { + return false; + } + i += 4; + } else { + return false; + } + } + return true; + } + function isBlob(value) { + return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File"); + } + module.exports = { + isBlob, + isValidStatusCode, + isValidUTF8: _isValidUTF8, + tokenChars + }; + if (isUtf8) { + module.exports.isValidUTF8 = function(buf) { + return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf); + }; + } else if (!process.env.WS_NO_UTF_8_VALIDATE) { + try { + const isValidUTF8 = __require("utf-8-validate"); + module.exports.isValidUTF8 = function(buf) { + return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf); + }; + } catch (e) { + } + } + } +}); + +// ../testeranto/node_modules/ws/lib/receiver.js +var require_receiver = __commonJS({ + "../testeranto/node_modules/ws/lib/receiver.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { Writable } = __require("stream"); + var PerMessageDeflate = require_permessage_deflate(); + var { + BINARY_TYPES, + EMPTY_BUFFER, + kStatusCode, + kWebSocket + } = require_constants(); + var { concat, toArrayBuffer, unmask } = require_buffer_util(); + var { isValidStatusCode, isValidUTF8 } = require_validation(); + var FastBuffer = Buffer[Symbol.species]; + var GET_INFO = 0; + var GET_PAYLOAD_LENGTH_16 = 1; + var GET_PAYLOAD_LENGTH_64 = 2; + var GET_MASK = 3; + var GET_DATA = 4; + var INFLATING = 5; + var DEFER_EVENT = 6; + var Receiver2 = class extends Writable { + /** + * Creates a Receiver instance. + * + * @param {Object} [options] Options object + * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether + * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted + * multiple times in the same tick + * @param {String} [options.binaryType=nodebuffer] The type for binary data + * @param {Object} [options.extensions] An object containing the negotiated + * extensions + * @param {Boolean} [options.isServer=false] Specifies whether to operate in + * client or server mode + * @param {Number} [options.maxPayload=0] The maximum allowed message length + * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or + * not to skip UTF-8 validation for text and close messages + */ + constructor(options = {}) { + super(); + this._allowSynchronousEvents = options.allowSynchronousEvents !== void 0 ? options.allowSynchronousEvents : true; + this._binaryType = options.binaryType || BINARY_TYPES[0]; + this._extensions = options.extensions || {}; + this._isServer = !!options.isServer; + this._maxPayload = options.maxPayload | 0; + this._skipUTF8Validation = !!options.skipUTF8Validation; + this[kWebSocket] = void 0; + this._bufferedBytes = 0; + this._buffers = []; + this._compressed = false; + this._payloadLength = 0; + this._mask = void 0; + this._fragmented = 0; + this._masked = false; + this._fin = false; + this._opcode = 0; + this._totalPayloadLength = 0; + this._messageLength = 0; + this._fragments = []; + this._errored = false; + this._loop = false; + this._state = GET_INFO; + } + /** + * Implements `Writable.prototype._write()`. + * + * @param {Buffer} chunk The chunk of data to write + * @param {String} encoding The character encoding of `chunk` + * @param {Function} cb Callback + * @private + */ + _write(chunk, encoding, cb) { + if (this._opcode === 8 && this._state == GET_INFO) + return cb(); + this._bufferedBytes += chunk.length; + this._buffers.push(chunk); + this.startLoop(cb); + } + /** + * Consumes `n` bytes from the buffered data. + * + * @param {Number} n The number of bytes to consume + * @return {Buffer} The consumed bytes + * @private + */ + consume(n) { + this._bufferedBytes -= n; + if (n === this._buffers[0].length) + return this._buffers.shift(); + if (n < this._buffers[0].length) { + const buf = this._buffers[0]; + this._buffers[0] = new FastBuffer( + buf.buffer, + buf.byteOffset + n, + buf.length - n + ); + return new FastBuffer(buf.buffer, buf.byteOffset, n); + } + const dst = Buffer.allocUnsafe(n); + do { + const buf = this._buffers[0]; + const offset = dst.length - n; + if (n >= buf.length) { + dst.set(this._buffers.shift(), offset); + } else { + dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset); + this._buffers[0] = new FastBuffer( + buf.buffer, + buf.byteOffset + n, + buf.length - n + ); + } + n -= buf.length; + } while (n > 0); + return dst; + } + /** + * Starts the parsing loop. + * + * @param {Function} cb Callback + * @private + */ + startLoop(cb) { + this._loop = true; + do { + switch (this._state) { + case GET_INFO: + this.getInfo(cb); + break; + case GET_PAYLOAD_LENGTH_16: + this.getPayloadLength16(cb); + break; + case GET_PAYLOAD_LENGTH_64: + this.getPayloadLength64(cb); + break; + case GET_MASK: + this.getMask(); + break; + case GET_DATA: + this.getData(cb); + break; + case INFLATING: + case DEFER_EVENT: + this._loop = false; + return; + } + } while (this._loop); + if (!this._errored) + cb(); + } + /** + * Reads the first two bytes of a frame. + * + * @param {Function} cb Callback + * @private + */ + getInfo(cb) { + if (this._bufferedBytes < 2) { + this._loop = false; + return; + } + const buf = this.consume(2); + if ((buf[0] & 48) !== 0) { + const error = this.createError( + RangeError, + "RSV2 and RSV3 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_2_3" + ); + cb(error); + return; + } + const compressed = (buf[0] & 64) === 64; + if (compressed && !this._extensions[PerMessageDeflate.extensionName]) { + const error = this.createError( + RangeError, + "RSV1 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_1" + ); + cb(error); + return; + } + this._fin = (buf[0] & 128) === 128; + this._opcode = buf[0] & 15; + this._payloadLength = buf[1] & 127; + if (this._opcode === 0) { + if (compressed) { + const error = this.createError( + RangeError, + "RSV1 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_1" + ); + cb(error); + return; + } + if (!this._fragmented) { + const error = this.createError( + RangeError, + "invalid opcode 0", + true, + 1002, + "WS_ERR_INVALID_OPCODE" + ); + cb(error); + return; + } + this._opcode = this._fragmented; + } else if (this._opcode === 1 || this._opcode === 2) { + if (this._fragmented) { + const error = this.createError( + RangeError, + `invalid opcode ${this._opcode}`, + true, + 1002, + "WS_ERR_INVALID_OPCODE" + ); + cb(error); + return; + } + this._compressed = compressed; + } else if (this._opcode > 7 && this._opcode < 11) { + if (!this._fin) { + const error = this.createError( + RangeError, + "FIN must be set", + true, + 1002, + "WS_ERR_EXPECTED_FIN" + ); + cb(error); + return; + } + if (compressed) { + const error = this.createError( + RangeError, + "RSV1 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_1" + ); + cb(error); + return; + } + if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) { + const error = this.createError( + RangeError, + `invalid payload length ${this._payloadLength}`, + true, + 1002, + "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH" + ); + cb(error); + return; + } + } else { + const error = this.createError( + RangeError, + `invalid opcode ${this._opcode}`, + true, + 1002, + "WS_ERR_INVALID_OPCODE" + ); + cb(error); + return; + } + if (!this._fin && !this._fragmented) + this._fragmented = this._opcode; + this._masked = (buf[1] & 128) === 128; + if (this._isServer) { + if (!this._masked) { + const error = this.createError( + RangeError, + "MASK must be set", + true, + 1002, + "WS_ERR_EXPECTED_MASK" + ); + cb(error); + return; + } + } else if (this._masked) { + const error = this.createError( + RangeError, + "MASK must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_MASK" + ); + cb(error); + return; + } + if (this._payloadLength === 126) + this._state = GET_PAYLOAD_LENGTH_16; + else if (this._payloadLength === 127) + this._state = GET_PAYLOAD_LENGTH_64; + else + this.haveLength(cb); + } + /** + * Gets extended payload length (7+16). + * + * @param {Function} cb Callback + * @private + */ + getPayloadLength16(cb) { + if (this._bufferedBytes < 2) { + this._loop = false; + return; + } + this._payloadLength = this.consume(2).readUInt16BE(0); + this.haveLength(cb); + } + /** + * Gets extended payload length (7+64). + * + * @param {Function} cb Callback + * @private + */ + getPayloadLength64(cb) { + if (this._bufferedBytes < 8) { + this._loop = false; + return; + } + const buf = this.consume(8); + const num = buf.readUInt32BE(0); + if (num > Math.pow(2, 53 - 32) - 1) { + const error = this.createError( + RangeError, + "Unsupported WebSocket frame: payload length > 2^53 - 1", + false, + 1009, + "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH" + ); + cb(error); + return; + } + this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4); + this.haveLength(cb); + } + /** + * Payload length has been read. + * + * @param {Function} cb Callback + * @private + */ + haveLength(cb) { + if (this._payloadLength && this._opcode < 8) { + this._totalPayloadLength += this._payloadLength; + if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) { + const error = this.createError( + RangeError, + "Max payload size exceeded", + false, + 1009, + "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" + ); + cb(error); + return; + } + } + if (this._masked) + this._state = GET_MASK; + else + this._state = GET_DATA; + } + /** + * Reads mask bytes. + * + * @private + */ + getMask() { + if (this._bufferedBytes < 4) { + this._loop = false; + return; + } + this._mask = this.consume(4); + this._state = GET_DATA; + } + /** + * Reads data bytes. + * + * @param {Function} cb Callback + * @private + */ + getData(cb) { + let data = EMPTY_BUFFER; + if (this._payloadLength) { + if (this._bufferedBytes < this._payloadLength) { + this._loop = false; + return; + } + data = this.consume(this._payloadLength); + if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) { + unmask(data, this._mask); + } + } + if (this._opcode > 7) { + this.controlMessage(data, cb); + return; + } + if (this._compressed) { + this._state = INFLATING; + this.decompress(data, cb); + return; + } + if (data.length) { + this._messageLength = this._totalPayloadLength; + this._fragments.push(data); + } + this.dataMessage(cb); + } + /** + * Decompresses data. + * + * @param {Buffer} data Compressed data + * @param {Function} cb Callback + * @private + */ + decompress(data, cb) { + const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName]; + perMessageDeflate.decompress(data, this._fin, (err, buf) => { + if (err) + return cb(err); + if (buf.length) { + this._messageLength += buf.length; + if (this._messageLength > this._maxPayload && this._maxPayload > 0) { + const error = this.createError( + RangeError, + "Max payload size exceeded", + false, + 1009, + "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" + ); + cb(error); + return; + } + this._fragments.push(buf); + } + this.dataMessage(cb); + if (this._state === GET_INFO) + this.startLoop(cb); + }); + } + /** + * Handles a data message. + * + * @param {Function} cb Callback + * @private + */ + dataMessage(cb) { + if (!this._fin) { + this._state = GET_INFO; + return; + } + const messageLength = this._messageLength; + const fragments = this._fragments; + this._totalPayloadLength = 0; + this._messageLength = 0; + this._fragmented = 0; + this._fragments = []; + if (this._opcode === 2) { + let data; + if (this._binaryType === "nodebuffer") { + data = concat(fragments, messageLength); + } else if (this._binaryType === "arraybuffer") { + data = toArrayBuffer(concat(fragments, messageLength)); + } else if (this._binaryType === "blob") { + data = new Blob(fragments); + } else { + data = fragments; + } + if (this._allowSynchronousEvents) { + this.emit("message", data, true); + this._state = GET_INFO; + } else { + this._state = DEFER_EVENT; + setImmediate(() => { + this.emit("message", data, true); + this._state = GET_INFO; + this.startLoop(cb); + }); + } + } else { + const buf = concat(fragments, messageLength); + if (!this._skipUTF8Validation && !isValidUTF8(buf)) { + const error = this.createError( + Error, + "invalid UTF-8 sequence", + true, + 1007, + "WS_ERR_INVALID_UTF8" + ); + cb(error); + return; + } + if (this._state === INFLATING || this._allowSynchronousEvents) { + this.emit("message", buf, false); + this._state = GET_INFO; + } else { + this._state = DEFER_EVENT; + setImmediate(() => { + this.emit("message", buf, false); + this._state = GET_INFO; + this.startLoop(cb); + }); + } + } + } + /** + * Handles a control message. + * + * @param {Buffer} data Data to handle + * @return {(Error|RangeError|undefined)} A possible error + * @private + */ + controlMessage(data, cb) { + if (this._opcode === 8) { + if (data.length === 0) { + this._loop = false; + this.emit("conclude", 1005, EMPTY_BUFFER); + this.end(); + } else { + const code = data.readUInt16BE(0); + if (!isValidStatusCode(code)) { + const error = this.createError( + RangeError, + `invalid status code ${code}`, + true, + 1002, + "WS_ERR_INVALID_CLOSE_CODE" + ); + cb(error); + return; + } + const buf = new FastBuffer( + data.buffer, + data.byteOffset + 2, + data.length - 2 + ); + if (!this._skipUTF8Validation && !isValidUTF8(buf)) { + const error = this.createError( + Error, + "invalid UTF-8 sequence", + true, + 1007, + "WS_ERR_INVALID_UTF8" + ); + cb(error); + return; + } + this._loop = false; + this.emit("conclude", code, buf); + this.end(); + } + this._state = GET_INFO; + return; + } + if (this._allowSynchronousEvents) { + this.emit(this._opcode === 9 ? "ping" : "pong", data); + this._state = GET_INFO; + } else { + this._state = DEFER_EVENT; + setImmediate(() => { + this.emit(this._opcode === 9 ? "ping" : "pong", data); + this._state = GET_INFO; + this.startLoop(cb); + }); + } + } + /** + * Builds an error object. + * + * @param {function(new:Error|RangeError)} ErrorCtor The error constructor + * @param {String} message The error message + * @param {Boolean} prefix Specifies whether or not to add a default prefix to + * `message` + * @param {Number} statusCode The status code + * @param {String} errorCode The exposed error code + * @return {(Error|RangeError)} The error + * @private + */ + createError(ErrorCtor, message, prefix, statusCode, errorCode) { + this._loop = false; + this._errored = true; + const err = new ErrorCtor( + prefix ? `Invalid WebSocket frame: ${message}` : message + ); + Error.captureStackTrace(err, this.createError); + err.code = errorCode; + err[kStatusCode] = statusCode; + return err; + } + }; + module.exports = Receiver2; + } +}); + +// ../testeranto/node_modules/ws/lib/sender.js +var require_sender = __commonJS({ + "../testeranto/node_modules/ws/lib/sender.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { Duplex } = __require("stream"); + var { randomFillSync } = __require("crypto"); + var PerMessageDeflate = require_permessage_deflate(); + var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants(); + var { isBlob, isValidStatusCode } = require_validation(); + var { mask: applyMask, toBuffer } = require_buffer_util(); + var kByteLength = Symbol("kByteLength"); + var maskBuffer = Buffer.alloc(4); + var RANDOM_POOL_SIZE = 8 * 1024; + var randomPool; + var randomPoolPointer = RANDOM_POOL_SIZE; + var DEFAULT = 0; + var DEFLATING = 1; + var GET_BLOB_DATA = 2; + var Sender2 = class { + /** + * Creates a Sender instance. + * + * @param {Duplex} socket The connection socket + * @param {Object} [extensions] An object containing the negotiated extensions + * @param {Function} [generateMask] The function used to generate the masking + * key + */ + constructor(socket, extensions, generateMask) { + this._extensions = extensions || {}; + if (generateMask) { + this._generateMask = generateMask; + this._maskBuffer = Buffer.alloc(4); + } + this._socket = socket; + this._firstFragment = true; + this._compress = false; + this._bufferedBytes = 0; + this._queue = []; + this._state = DEFAULT; + this.onerror = NOOP; + this[kWebSocket] = void 0; + } + /** + * Frames a piece of data according to the HyBi WebSocket protocol. + * + * @param {(Buffer|String)} data The data to frame + * @param {Object} options Options object + * @param {Boolean} [options.fin=false] Specifies whether or not to set the + * FIN bit + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Buffer} [options.maskBuffer] The buffer used to store the masking + * key + * @param {Number} options.opcode The opcode + * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be + * modified + * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the + * RSV1 bit + * @return {(Buffer|String)[]} The framed data + * @public + */ + static frame(data, options) { + let mask; + let merge = false; + let offset = 2; + let skipMasking = false; + if (options.mask) { + mask = options.maskBuffer || maskBuffer; + if (options.generateMask) { + options.generateMask(mask); + } else { + if (randomPoolPointer === RANDOM_POOL_SIZE) { + if (randomPool === void 0) { + randomPool = Buffer.alloc(RANDOM_POOL_SIZE); + } + randomFillSync(randomPool, 0, RANDOM_POOL_SIZE); + randomPoolPointer = 0; + } + mask[0] = randomPool[randomPoolPointer++]; + mask[1] = randomPool[randomPoolPointer++]; + mask[2] = randomPool[randomPoolPointer++]; + mask[3] = randomPool[randomPoolPointer++]; + } + skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0; + offset = 6; + } + let dataLength; + if (typeof data === "string") { + if ((!options.mask || skipMasking) && options[kByteLength] !== void 0) { + dataLength = options[kByteLength]; + } else { + data = Buffer.from(data); + dataLength = data.length; + } + } else { + dataLength = data.length; + merge = options.mask && options.readOnly && !skipMasking; + } + let payloadLength = dataLength; + if (dataLength >= 65536) { + offset += 8; + payloadLength = 127; + } else if (dataLength > 125) { + offset += 2; + payloadLength = 126; + } + const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset); + target[0] = options.fin ? options.opcode | 128 : options.opcode; + if (options.rsv1) + target[0] |= 64; + target[1] = payloadLength; + if (payloadLength === 126) { + target.writeUInt16BE(dataLength, 2); + } else if (payloadLength === 127) { + target[2] = target[3] = 0; + target.writeUIntBE(dataLength, 4, 6); + } + if (!options.mask) + return [target, data]; + target[1] |= 128; + target[offset - 4] = mask[0]; + target[offset - 3] = mask[1]; + target[offset - 2] = mask[2]; + target[offset - 1] = mask[3]; + if (skipMasking) + return [target, data]; + if (merge) { + applyMask(data, mask, target, offset, dataLength); + return [target]; + } + applyMask(data, mask, data, 0, dataLength); + return [target, data]; + } + /** + * Sends a close message to the other peer. + * + * @param {Number} [code] The status code component of the body + * @param {(String|Buffer)} [data] The message component of the body + * @param {Boolean} [mask=false] Specifies whether or not to mask the message + * @param {Function} [cb] Callback + * @public + */ + close(code, data, mask, cb) { + let buf; + if (code === void 0) { + buf = EMPTY_BUFFER; + } else if (typeof code !== "number" || !isValidStatusCode(code)) { + throw new TypeError("First argument must be a valid error code number"); + } else if (data === void 0 || !data.length) { + buf = Buffer.allocUnsafe(2); + buf.writeUInt16BE(code, 0); + } else { + const length = Buffer.byteLength(data); + if (length > 123) { + throw new RangeError("The message must not be greater than 123 bytes"); + } + buf = Buffer.allocUnsafe(2 + length); + buf.writeUInt16BE(code, 0); + if (typeof data === "string") { + buf.write(data, 2); + } else { + buf.set(data, 2); + } + } + const options = { + [kByteLength]: buf.length, + fin: true, + generateMask: this._generateMask, + mask, + maskBuffer: this._maskBuffer, + opcode: 8, + readOnly: false, + rsv1: false + }; + if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, buf, false, options, cb]); + } else { + this.sendFrame(Sender2.frame(buf, options), cb); + } + } + /** + * Sends a ping message to the other peer. + * + * @param {*} data The message to send + * @param {Boolean} [mask=false] Specifies whether or not to mask `data` + * @param {Function} [cb] Callback + * @public + */ + ping(data, mask, cb) { + let byteLength; + let readOnly; + if (typeof data === "string") { + byteLength = Buffer.byteLength(data); + readOnly = false; + } else if (isBlob(data)) { + byteLength = data.size; + readOnly = false; + } else { + data = toBuffer(data); + byteLength = data.length; + readOnly = toBuffer.readOnly; + } + if (byteLength > 125) { + throw new RangeError("The data size must not be greater than 125 bytes"); + } + const options = { + [kByteLength]: byteLength, + fin: true, + generateMask: this._generateMask, + mask, + maskBuffer: this._maskBuffer, + opcode: 9, + readOnly, + rsv1: false + }; + if (isBlob(data)) { + if (this._state !== DEFAULT) { + this.enqueue([this.getBlobData, data, false, options, cb]); + } else { + this.getBlobData(data, false, options, cb); + } + } else if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, data, false, options, cb]); + } else { + this.sendFrame(Sender2.frame(data, options), cb); + } + } + /** + * Sends a pong message to the other peer. + * + * @param {*} data The message to send + * @param {Boolean} [mask=false] Specifies whether or not to mask `data` + * @param {Function} [cb] Callback + * @public + */ + pong(data, mask, cb) { + let byteLength; + let readOnly; + if (typeof data === "string") { + byteLength = Buffer.byteLength(data); + readOnly = false; + } else if (isBlob(data)) { + byteLength = data.size; + readOnly = false; + } else { + data = toBuffer(data); + byteLength = data.length; + readOnly = toBuffer.readOnly; + } + if (byteLength > 125) { + throw new RangeError("The data size must not be greater than 125 bytes"); + } + const options = { + [kByteLength]: byteLength, + fin: true, + generateMask: this._generateMask, + mask, + maskBuffer: this._maskBuffer, + opcode: 10, + readOnly, + rsv1: false + }; + if (isBlob(data)) { + if (this._state !== DEFAULT) { + this.enqueue([this.getBlobData, data, false, options, cb]); + } else { + this.getBlobData(data, false, options, cb); + } + } else if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, data, false, options, cb]); + } else { + this.sendFrame(Sender2.frame(data, options), cb); + } + } + /** + * Sends a data message to the other peer. + * + * @param {*} data The message to send + * @param {Object} options Options object + * @param {Boolean} [options.binary=false] Specifies whether `data` is binary + * or text + * @param {Boolean} [options.compress=false] Specifies whether or not to + * compress `data` + * @param {Boolean} [options.fin=false] Specifies whether the fragment is the + * last one + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Function} [cb] Callback + * @public + */ + send(data, options, cb) { + const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName]; + let opcode = options.binary ? 2 : 1; + let rsv1 = options.compress; + let byteLength; + let readOnly; + if (typeof data === "string") { + byteLength = Buffer.byteLength(data); + readOnly = false; + } else if (isBlob(data)) { + byteLength = data.size; + readOnly = false; + } else { + data = toBuffer(data); + byteLength = data.length; + readOnly = toBuffer.readOnly; + } + if (this._firstFragment) { + this._firstFragment = false; + if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) { + rsv1 = byteLength >= perMessageDeflate._threshold; + } + this._compress = rsv1; + } else { + rsv1 = false; + opcode = 0; + } + if (options.fin) + this._firstFragment = true; + const opts = { + [kByteLength]: byteLength, + fin: options.fin, + generateMask: this._generateMask, + mask: options.mask, + maskBuffer: this._maskBuffer, + opcode, + readOnly, + rsv1 + }; + if (isBlob(data)) { + if (this._state !== DEFAULT) { + this.enqueue([this.getBlobData, data, this._compress, opts, cb]); + } else { + this.getBlobData(data, this._compress, opts, cb); + } + } else if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, data, this._compress, opts, cb]); + } else { + this.dispatch(data, this._compress, opts, cb); + } + } + /** + * Gets the contents of a blob as binary data. + * + * @param {Blob} blob The blob + * @param {Boolean} [compress=false] Specifies whether or not to compress + * the data + * @param {Object} options Options object + * @param {Boolean} [options.fin=false] Specifies whether or not to set the + * FIN bit + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Buffer} [options.maskBuffer] The buffer used to store the masking + * key + * @param {Number} options.opcode The opcode + * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be + * modified + * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the + * RSV1 bit + * @param {Function} [cb] Callback + * @private + */ + getBlobData(blob, compress, options, cb) { + this._bufferedBytes += options[kByteLength]; + this._state = GET_BLOB_DATA; + blob.arrayBuffer().then((arrayBuffer) => { + if (this._socket.destroyed) { + const err = new Error( + "The socket was closed while the blob was being read" + ); + process.nextTick(callCallbacks, this, err, cb); + return; + } + this._bufferedBytes -= options[kByteLength]; + const data = toBuffer(arrayBuffer); + if (!compress) { + this._state = DEFAULT; + this.sendFrame(Sender2.frame(data, options), cb); + this.dequeue(); + } else { + this.dispatch(data, compress, options, cb); + } + }).catch((err) => { + process.nextTick(onError, this, err, cb); + }); + } + /** + * Dispatches a message. + * + * @param {(Buffer|String)} data The message to send + * @param {Boolean} [compress=false] Specifies whether or not to compress + * `data` + * @param {Object} options Options object + * @param {Boolean} [options.fin=false] Specifies whether or not to set the + * FIN bit + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Buffer} [options.maskBuffer] The buffer used to store the masking + * key + * @param {Number} options.opcode The opcode + * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be + * modified + * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the + * RSV1 bit + * @param {Function} [cb] Callback + * @private + */ + dispatch(data, compress, options, cb) { + if (!compress) { + this.sendFrame(Sender2.frame(data, options), cb); + return; + } + const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName]; + this._bufferedBytes += options[kByteLength]; + this._state = DEFLATING; + perMessageDeflate.compress(data, options.fin, (_, buf) => { + if (this._socket.destroyed) { + const err = new Error( + "The socket was closed while data was being compressed" + ); + callCallbacks(this, err, cb); + return; + } + this._bufferedBytes -= options[kByteLength]; + this._state = DEFAULT; + options.readOnly = false; + this.sendFrame(Sender2.frame(buf, options), cb); + this.dequeue(); + }); + } + /** + * Executes queued send operations. + * + * @private + */ + dequeue() { + while (this._state === DEFAULT && this._queue.length) { + const params = this._queue.shift(); + this._bufferedBytes -= params[3][kByteLength]; + Reflect.apply(params[0], this, params.slice(1)); + } + } + /** + * Enqueues a send operation. + * + * @param {Array} params Send operation parameters. + * @private + */ + enqueue(params) { + this._bufferedBytes += params[3][kByteLength]; + this._queue.push(params); + } + /** + * Sends a frame. + * + * @param {Buffer[]} list The frame to send + * @param {Function} [cb] Callback + * @private + */ + sendFrame(list, cb) { + if (list.length === 2) { + this._socket.cork(); + this._socket.write(list[0]); + this._socket.write(list[1], cb); + this._socket.uncork(); + } else { + this._socket.write(list[0], cb); + } + } + }; + module.exports = Sender2; + function callCallbacks(sender, err, cb) { + if (typeof cb === "function") + cb(err); + for (let i = 0; i < sender._queue.length; i++) { + const params = sender._queue[i]; + const callback = params[params.length - 1]; + if (typeof callback === "function") + callback(err); + } + } + function onError(sender, err, cb) { + callCallbacks(sender, err, cb); + sender.onerror(err); + } + } +}); + +// ../testeranto/node_modules/ws/lib/event-target.js +var require_event_target = __commonJS({ + "../testeranto/node_modules/ws/lib/event-target.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { kForOnEventAttribute, kListener } = require_constants(); + var kCode = Symbol("kCode"); + var kData = Symbol("kData"); + var kError = Symbol("kError"); + var kMessage = Symbol("kMessage"); + var kReason = Symbol("kReason"); + var kTarget = Symbol("kTarget"); + var kType = Symbol("kType"); + var kWasClean = Symbol("kWasClean"); + var Event = class { + /** + * Create a new `Event`. + * + * @param {String} type The name of the event + * @throws {TypeError} If the `type` argument is not specified + */ + constructor(type) { + this[kTarget] = null; + this[kType] = type; + } + /** + * @type {*} + */ + get target() { + return this[kTarget]; + } + /** + * @type {String} + */ + get type() { + return this[kType]; + } + }; + Object.defineProperty(Event.prototype, "target", { enumerable: true }); + Object.defineProperty(Event.prototype, "type", { enumerable: true }); + var CloseEvent = class extends Event { + /** + * Create a new `CloseEvent`. + * + * @param {String} type The name of the event + * @param {Object} [options] A dictionary object that allows for setting + * attributes via object members of the same name + * @param {Number} [options.code=0] The status code explaining why the + * connection was closed + * @param {String} [options.reason=''] A human-readable string explaining why + * the connection was closed + * @param {Boolean} [options.wasClean=false] Indicates whether or not the + * connection was cleanly closed + */ + constructor(type, options = {}) { + super(type); + this[kCode] = options.code === void 0 ? 0 : options.code; + this[kReason] = options.reason === void 0 ? "" : options.reason; + this[kWasClean] = options.wasClean === void 0 ? false : options.wasClean; + } + /** + * @type {Number} + */ + get code() { + return this[kCode]; + } + /** + * @type {String} + */ + get reason() { + return this[kReason]; + } + /** + * @type {Boolean} + */ + get wasClean() { + return this[kWasClean]; + } + }; + Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true }); + Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true }); + Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true }); + var ErrorEvent = class extends Event { + /** + * Create a new `ErrorEvent`. + * + * @param {String} type The name of the event + * @param {Object} [options] A dictionary object that allows for setting + * attributes via object members of the same name + * @param {*} [options.error=null] The error that generated this event + * @param {String} [options.message=''] The error message + */ + constructor(type, options = {}) { + super(type); + this[kError] = options.error === void 0 ? null : options.error; + this[kMessage] = options.message === void 0 ? "" : options.message; + } + /** + * @type {*} + */ + get error() { + return this[kError]; + } + /** + * @type {String} + */ + get message() { + return this[kMessage]; + } + }; + Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true }); + Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true }); + var MessageEvent = class extends Event { + /** + * Create a new `MessageEvent`. + * + * @param {String} type The name of the event + * @param {Object} [options] A dictionary object that allows for setting + * attributes via object members of the same name + * @param {*} [options.data=null] The message content + */ + constructor(type, options = {}) { + super(type); + this[kData] = options.data === void 0 ? null : options.data; + } + /** + * @type {*} + */ + get data() { + return this[kData]; + } + }; + Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true }); + var EventTarget = { + /** + * Register an event listener. + * + * @param {String} type A string representing the event type to listen for + * @param {(Function|Object)} handler The listener to add + * @param {Object} [options] An options object specifies characteristics about + * the event listener + * @param {Boolean} [options.once=false] A `Boolean` indicating that the + * listener should be invoked at most once after being added. If `true`, + * the listener would be automatically removed when invoked. + * @public + */ + addEventListener(type, handler, options = {}) { + for (const listener of this.listeners(type)) { + if (!options[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) { + return; + } + } + let wrapper; + if (type === "message") { + wrapper = function onMessage(data, isBinary) { + const event = new MessageEvent("message", { + data: isBinary ? data : data.toString() + }); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else if (type === "close") { + wrapper = function onClose(code, message) { + const event = new CloseEvent("close", { + code, + reason: message.toString(), + wasClean: this._closeFrameReceived && this._closeFrameSent + }); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else if (type === "error") { + wrapper = function onError(error) { + const event = new ErrorEvent("error", { + error, + message: error.message + }); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else if (type === "open") { + wrapper = function onOpen() { + const event = new Event("open"); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else { + return; + } + wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute]; + wrapper[kListener] = handler; + if (options.once) { + this.once(type, wrapper); + } else { + this.on(type, wrapper); + } + }, + /** + * Remove an event listener. + * + * @param {String} type A string representing the event type to remove + * @param {(Function|Object)} handler The listener to remove + * @public + */ + removeEventListener(type, handler) { + for (const listener of this.listeners(type)) { + if (listener[kListener] === handler && !listener[kForOnEventAttribute]) { + this.removeListener(type, listener); + break; + } + } + } + }; + module.exports = { + CloseEvent, + ErrorEvent, + Event, + EventTarget, + MessageEvent + }; + function callListener(listener, thisArg, event) { + if (typeof listener === "object" && listener.handleEvent) { + listener.handleEvent.call(listener, event); + } else { + listener.call(thisArg, event); + } + } + } +}); + +// ../testeranto/node_modules/ws/lib/extension.js +var require_extension = __commonJS({ + "../testeranto/node_modules/ws/lib/extension.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { tokenChars } = require_validation(); + function push(dest, name, elem) { + if (dest[name] === void 0) + dest[name] = [elem]; + else + dest[name].push(elem); + } + function parse(header) { + const offers = /* @__PURE__ */ Object.create(null); + let params = /* @__PURE__ */ Object.create(null); + let mustUnescape = false; + let isEscaping = false; + let inQuotes = false; + let extensionName; + let paramName; + let start = -1; + let code = -1; + let end = -1; + let i = 0; + for (; i < header.length; i++) { + code = header.charCodeAt(i); + if (extensionName === void 0) { + if (end === -1 && tokenChars[code] === 1) { + if (start === -1) + start = i; + } else if (i !== 0 && (code === 32 || code === 9)) { + if (end === -1 && start !== -1) + end = i; + } else if (code === 59 || code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) + end = i; + const name = header.slice(start, end); + if (code === 44) { + push(offers, name, params); + params = /* @__PURE__ */ Object.create(null); + } else { + extensionName = name; + } + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } else if (paramName === void 0) { + if (end === -1 && tokenChars[code] === 1) { + if (start === -1) + start = i; + } else if (code === 32 || code === 9) { + if (end === -1 && start !== -1) + end = i; + } else if (code === 59 || code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) + end = i; + push(params, header.slice(start, end), true); + if (code === 44) { + push(offers, extensionName, params); + params = /* @__PURE__ */ Object.create(null); + extensionName = void 0; + } + start = end = -1; + } else if (code === 61 && start !== -1 && end === -1) { + paramName = header.slice(start, i); + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } else { + if (isEscaping) { + if (tokenChars[code] !== 1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (start === -1) + start = i; + else if (!mustUnescape) + mustUnescape = true; + isEscaping = false; + } else if (inQuotes) { + if (tokenChars[code] === 1) { + if (start === -1) + start = i; + } else if (code === 34 && start !== -1) { + inQuotes = false; + end = i; + } else if (code === 92) { + isEscaping = true; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } else if (code === 34 && header.charCodeAt(i - 1) === 61) { + inQuotes = true; + } else if (end === -1 && tokenChars[code] === 1) { + if (start === -1) + start = i; + } else if (start !== -1 && (code === 32 || code === 9)) { + if (end === -1) + end = i; + } else if (code === 59 || code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) + end = i; + let value = header.slice(start, end); + if (mustUnescape) { + value = value.replace(/\\/g, ""); + mustUnescape = false; + } + push(params, paramName, value); + if (code === 44) { + push(offers, extensionName, params); + params = /* @__PURE__ */ Object.create(null); + extensionName = void 0; + } + paramName = void 0; + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } + } + if (start === -1 || inQuotes || code === 32 || code === 9) { + throw new SyntaxError("Unexpected end of input"); + } + if (end === -1) + end = i; + const token = header.slice(start, end); + if (extensionName === void 0) { + push(offers, token, params); + } else { + if (paramName === void 0) { + push(params, token, true); + } else if (mustUnescape) { + push(params, paramName, token.replace(/\\/g, "")); + } else { + push(params, paramName, token); + } + push(offers, extensionName, params); + } + return offers; + } + function format(extensions) { + return Object.keys(extensions).map((extension) => { + let configurations = extensions[extension]; + if (!Array.isArray(configurations)) + configurations = [configurations]; + return configurations.map((params) => { + return [extension].concat( + Object.keys(params).map((k) => { + let values = params[k]; + if (!Array.isArray(values)) + values = [values]; + return values.map((v) => v === true ? k : `${k}=${v}`).join("; "); + }) + ).join("; "); + }).join(", "); + }).join(", "); + } + module.exports = { format, parse }; + } +}); + +// ../testeranto/node_modules/ws/lib/websocket.js +var require_websocket = __commonJS({ + "../testeranto/node_modules/ws/lib/websocket.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var EventEmitter = __require("events"); + var https = __require("https"); + var http = __require("http"); + var net = __require("net"); + var tls = __require("tls"); + var { randomBytes, createHash } = __require("crypto"); + var { Duplex, Readable } = __require("stream"); + var { URL } = __require("url"); + var PerMessageDeflate = require_permessage_deflate(); + var Receiver2 = require_receiver(); + var Sender2 = require_sender(); + var { isBlob } = require_validation(); + var { + BINARY_TYPES, + EMPTY_BUFFER, + GUID, + kForOnEventAttribute, + kListener, + kStatusCode, + kWebSocket, + NOOP + } = require_constants(); + var { + EventTarget: { addEventListener, removeEventListener } + } = require_event_target(); + var { format, parse } = require_extension(); + var { toBuffer } = require_buffer_util(); + var closeTimeout = 30 * 1e3; + var kAborted = Symbol("kAborted"); + var protocolVersions = [8, 13]; + var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"]; + var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/; + var WebSocket2 = class extends EventEmitter { + /** + * Create a new `WebSocket`. + * + * @param {(String|URL)} address The URL to which to connect + * @param {(String|String[])} [protocols] The subprotocols + * @param {Object} [options] Connection options + */ + constructor(address, protocols, options) { + super(); + this._binaryType = BINARY_TYPES[0]; + this._closeCode = 1006; + this._closeFrameReceived = false; + this._closeFrameSent = false; + this._closeMessage = EMPTY_BUFFER; + this._closeTimer = null; + this._errorEmitted = false; + this._extensions = {}; + this._paused = false; + this._protocol = ""; + this._readyState = WebSocket2.CONNECTING; + this._receiver = null; + this._sender = null; + this._socket = null; + if (address !== null) { + this._bufferedAmount = 0; + this._isServer = false; + this._redirects = 0; + if (protocols === void 0) { + protocols = []; + } else if (!Array.isArray(protocols)) { + if (typeof protocols === "object" && protocols !== null) { + options = protocols; + protocols = []; + } else { + protocols = [protocols]; + } + } + initAsClient(this, address, protocols, options); + } else { + this._autoPong = options.autoPong; + this._isServer = true; + } + } + /** + * For historical reasons, the custom "nodebuffer" type is used by the default + * instead of "blob". + * + * @type {String} + */ + get binaryType() { + return this._binaryType; + } + set binaryType(type) { + if (!BINARY_TYPES.includes(type)) + return; + this._binaryType = type; + if (this._receiver) + this._receiver._binaryType = type; + } + /** + * @type {Number} + */ + get bufferedAmount() { + if (!this._socket) + return this._bufferedAmount; + return this._socket._writableState.length + this._sender._bufferedBytes; + } + /** + * @type {String} + */ + get extensions() { + return Object.keys(this._extensions).join(); + } + /** + * @type {Boolean} + */ + get isPaused() { + return this._paused; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onclose() { + return null; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onerror() { + return null; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onopen() { + return null; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onmessage() { + return null; + } + /** + * @type {String} + */ + get protocol() { + return this._protocol; + } + /** + * @type {Number} + */ + get readyState() { + return this._readyState; + } + /** + * @type {String} + */ + get url() { + return this._url; + } + /** + * Set up the socket and the internal resources. + * + * @param {Duplex} socket The network socket between the server and client + * @param {Buffer} head The first packet of the upgraded stream + * @param {Object} options Options object + * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether + * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted + * multiple times in the same tick + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Number} [options.maxPayload=0] The maximum allowed message size + * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or + * not to skip UTF-8 validation for text and close messages + * @private + */ + setSocket(socket, head, options) { + const receiver = new Receiver2({ + allowSynchronousEvents: options.allowSynchronousEvents, + binaryType: this.binaryType, + extensions: this._extensions, + isServer: this._isServer, + maxPayload: options.maxPayload, + skipUTF8Validation: options.skipUTF8Validation + }); + const sender = new Sender2(socket, this._extensions, options.generateMask); + this._receiver = receiver; + this._sender = sender; + this._socket = socket; + receiver[kWebSocket] = this; + sender[kWebSocket] = this; + socket[kWebSocket] = this; + receiver.on("conclude", receiverOnConclude); + receiver.on("drain", receiverOnDrain); + receiver.on("error", receiverOnError); + receiver.on("message", receiverOnMessage); + receiver.on("ping", receiverOnPing); + receiver.on("pong", receiverOnPong); + sender.onerror = senderOnError; + if (socket.setTimeout) + socket.setTimeout(0); + if (socket.setNoDelay) + socket.setNoDelay(); + if (head.length > 0) + socket.unshift(head); + socket.on("close", socketOnClose); + socket.on("data", socketOnData); + socket.on("end", socketOnEnd); + socket.on("error", socketOnError); + this._readyState = WebSocket2.OPEN; + this.emit("open"); + } + /** + * Emit the `'close'` event. + * + * @private + */ + emitClose() { + if (!this._socket) { + this._readyState = WebSocket2.CLOSED; + this.emit("close", this._closeCode, this._closeMessage); + return; + } + if (this._extensions[PerMessageDeflate.extensionName]) { + this._extensions[PerMessageDeflate.extensionName].cleanup(); + } + this._receiver.removeAllListeners(); + this._readyState = WebSocket2.CLOSED; + this.emit("close", this._closeCode, this._closeMessage); + } + /** + * Start a closing handshake. + * + * +----------+ +-----------+ +----------+ + * - - -|ws.close()|-->|close frame|-->|ws.close()|- - - + * | +----------+ +-----------+ +----------+ | + * +----------+ +-----------+ | + * CLOSING |ws.close()|<--|close frame|<--+-----+ CLOSING + * +----------+ +-----------+ | + * | | | +---+ | + * +------------------------+-->|fin| - - - - + * | +---+ | +---+ + * - - - - -|fin|<---------------------+ + * +---+ + * + * @param {Number} [code] Status code explaining why the connection is closing + * @param {(String|Buffer)} [data] The reason why the connection is + * closing + * @public + */ + close(code, data) { + if (this.readyState === WebSocket2.CLOSED) + return; + if (this.readyState === WebSocket2.CONNECTING) { + const msg = "WebSocket was closed before the connection was established"; + abortHandshake(this, this._req, msg); + return; + } + if (this.readyState === WebSocket2.CLOSING) { + if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) { + this._socket.end(); + } + return; + } + this._readyState = WebSocket2.CLOSING; + this._sender.close(code, data, !this._isServer, (err) => { + if (err) + return; + this._closeFrameSent = true; + if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) { + this._socket.end(); + } + }); + setCloseTimer(this); + } + /** + * Pause the socket. + * + * @public + */ + pause() { + if (this.readyState === WebSocket2.CONNECTING || this.readyState === WebSocket2.CLOSED) { + return; + } + this._paused = true; + this._socket.pause(); + } + /** + * Send a ping. + * + * @param {*} [data] The data to send + * @param {Boolean} [mask] Indicates whether or not to mask `data` + * @param {Function} [cb] Callback which is executed when the ping is sent + * @public + */ + ping(data, mask, cb) { + if (this.readyState === WebSocket2.CONNECTING) { + throw new Error("WebSocket is not open: readyState 0 (CONNECTING)"); + } + if (typeof data === "function") { + cb = data; + data = mask = void 0; + } else if (typeof mask === "function") { + cb = mask; + mask = void 0; + } + if (typeof data === "number") + data = data.toString(); + if (this.readyState !== WebSocket2.OPEN) { + sendAfterClose(this, data, cb); + return; + } + if (mask === void 0) + mask = !this._isServer; + this._sender.ping(data || EMPTY_BUFFER, mask, cb); + } + /** + * Send a pong. + * + * @param {*} [data] The data to send + * @param {Boolean} [mask] Indicates whether or not to mask `data` + * @param {Function} [cb] Callback which is executed when the pong is sent + * @public + */ + pong(data, mask, cb) { + if (this.readyState === WebSocket2.CONNECTING) { + throw new Error("WebSocket is not open: readyState 0 (CONNECTING)"); + } + if (typeof data === "function") { + cb = data; + data = mask = void 0; + } else if (typeof mask === "function") { + cb = mask; + mask = void 0; + } + if (typeof data === "number") + data = data.toString(); + if (this.readyState !== WebSocket2.OPEN) { + sendAfterClose(this, data, cb); + return; + } + if (mask === void 0) + mask = !this._isServer; + this._sender.pong(data || EMPTY_BUFFER, mask, cb); + } + /** + * Resume the socket. + * + * @public + */ + resume() { + if (this.readyState === WebSocket2.CONNECTING || this.readyState === WebSocket2.CLOSED) { + return; + } + this._paused = false; + if (!this._receiver._writableState.needDrain) + this._socket.resume(); + } + /** + * Send a data message. + * + * @param {*} data The message to send + * @param {Object} [options] Options object + * @param {Boolean} [options.binary] Specifies whether `data` is binary or + * text + * @param {Boolean} [options.compress] Specifies whether or not to compress + * `data` + * @param {Boolean} [options.fin=true] Specifies whether the fragment is the + * last one + * @param {Boolean} [options.mask] Specifies whether or not to mask `data` + * @param {Function} [cb] Callback which is executed when data is written out + * @public + */ + send(data, options, cb) { + if (this.readyState === WebSocket2.CONNECTING) { + throw new Error("WebSocket is not open: readyState 0 (CONNECTING)"); + } + if (typeof options === "function") { + cb = options; + options = {}; + } + if (typeof data === "number") + data = data.toString(); + if (this.readyState !== WebSocket2.OPEN) { + sendAfterClose(this, data, cb); + return; + } + const opts = { + binary: typeof data !== "string", + mask: !this._isServer, + compress: true, + fin: true, + ...options + }; + if (!this._extensions[PerMessageDeflate.extensionName]) { + opts.compress = false; + } + this._sender.send(data || EMPTY_BUFFER, opts, cb); + } + /** + * Forcibly close the connection. + * + * @public + */ + terminate() { + if (this.readyState === WebSocket2.CLOSED) + return; + if (this.readyState === WebSocket2.CONNECTING) { + const msg = "WebSocket was closed before the connection was established"; + abortHandshake(this, this._req, msg); + return; + } + if (this._socket) { + this._readyState = WebSocket2.CLOSING; + this._socket.destroy(); + } + } + }; + Object.defineProperty(WebSocket2, "CONNECTING", { + enumerable: true, + value: readyStates.indexOf("CONNECTING") + }); + Object.defineProperty(WebSocket2.prototype, "CONNECTING", { + enumerable: true, + value: readyStates.indexOf("CONNECTING") + }); + Object.defineProperty(WebSocket2, "OPEN", { + enumerable: true, + value: readyStates.indexOf("OPEN") + }); + Object.defineProperty(WebSocket2.prototype, "OPEN", { + enumerable: true, + value: readyStates.indexOf("OPEN") + }); + Object.defineProperty(WebSocket2, "CLOSING", { + enumerable: true, + value: readyStates.indexOf("CLOSING") + }); + Object.defineProperty(WebSocket2.prototype, "CLOSING", { + enumerable: true, + value: readyStates.indexOf("CLOSING") + }); + Object.defineProperty(WebSocket2, "CLOSED", { + enumerable: true, + value: readyStates.indexOf("CLOSED") + }); + Object.defineProperty(WebSocket2.prototype, "CLOSED", { + enumerable: true, + value: readyStates.indexOf("CLOSED") + }); + [ + "binaryType", + "bufferedAmount", + "extensions", + "isPaused", + "protocol", + "readyState", + "url" + ].forEach((property) => { + Object.defineProperty(WebSocket2.prototype, property, { enumerable: true }); + }); + ["open", "error", "close", "message"].forEach((method) => { + Object.defineProperty(WebSocket2.prototype, `on${method}`, { + enumerable: true, + get() { + for (const listener of this.listeners(method)) { + if (listener[kForOnEventAttribute]) + return listener[kListener]; + } + return null; + }, + set(handler) { + for (const listener of this.listeners(method)) { + if (listener[kForOnEventAttribute]) { + this.removeListener(method, listener); + break; + } + } + if (typeof handler !== "function") + return; + this.addEventListener(method, handler, { + [kForOnEventAttribute]: true + }); + } + }); + }); + WebSocket2.prototype.addEventListener = addEventListener; + WebSocket2.prototype.removeEventListener = removeEventListener; + module.exports = WebSocket2; + function initAsClient(websocket, address, protocols, options) { + const opts = { + allowSynchronousEvents: true, + autoPong: true, + protocolVersion: protocolVersions[1], + maxPayload: 100 * 1024 * 1024, + skipUTF8Validation: false, + perMessageDeflate: true, + followRedirects: false, + maxRedirects: 10, + ...options, + socketPath: void 0, + hostname: void 0, + protocol: void 0, + timeout: void 0, + method: "GET", + host: void 0, + path: void 0, + port: void 0 + }; + websocket._autoPong = opts.autoPong; + if (!protocolVersions.includes(opts.protocolVersion)) { + throw new RangeError( + `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})` + ); + } + let parsedUrl; + if (address instanceof URL) { + parsedUrl = address; + } else { + try { + parsedUrl = new URL(address); + } catch (e) { + throw new SyntaxError(`Invalid URL: ${address}`); + } + } + if (parsedUrl.protocol === "http:") { + parsedUrl.protocol = "ws:"; + } else if (parsedUrl.protocol === "https:") { + parsedUrl.protocol = "wss:"; + } + websocket._url = parsedUrl.href; + const isSecure = parsedUrl.protocol === "wss:"; + const isIpcUrl = parsedUrl.protocol === "ws+unix:"; + let invalidUrlMessage; + if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) { + invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", "http:", "https", or "ws+unix:"`; + } else if (isIpcUrl && !parsedUrl.pathname) { + invalidUrlMessage = "The URL's pathname is empty"; + } else if (parsedUrl.hash) { + invalidUrlMessage = "The URL contains a fragment identifier"; + } + if (invalidUrlMessage) { + const err = new SyntaxError(invalidUrlMessage); + if (websocket._redirects === 0) { + throw err; + } else { + emitErrorAndClose(websocket, err); + return; + } + } + const defaultPort = isSecure ? 443 : 80; + const key = randomBytes(16).toString("base64"); + const request = isSecure ? https.request : http.request; + const protocolSet = /* @__PURE__ */ new Set(); + let perMessageDeflate; + opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect); + opts.defaultPort = opts.defaultPort || defaultPort; + opts.port = parsedUrl.port || defaultPort; + opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname; + opts.headers = { + ...opts.headers, + "Sec-WebSocket-Version": opts.protocolVersion, + "Sec-WebSocket-Key": key, + Connection: "Upgrade", + Upgrade: "websocket" + }; + opts.path = parsedUrl.pathname + parsedUrl.search; + opts.timeout = opts.handshakeTimeout; + if (opts.perMessageDeflate) { + perMessageDeflate = new PerMessageDeflate( + opts.perMessageDeflate !== true ? opts.perMessageDeflate : {}, + false, + opts.maxPayload + ); + opts.headers["Sec-WebSocket-Extensions"] = format({ + [PerMessageDeflate.extensionName]: perMessageDeflate.offer() + }); + } + if (protocols.length) { + for (const protocol of protocols) { + if (typeof protocol !== "string" || !subprotocolRegex.test(protocol) || protocolSet.has(protocol)) { + throw new SyntaxError( + "An invalid or duplicated subprotocol was specified" + ); + } + protocolSet.add(protocol); + } + opts.headers["Sec-WebSocket-Protocol"] = protocols.join(","); + } + if (opts.origin) { + if (opts.protocolVersion < 13) { + opts.headers["Sec-WebSocket-Origin"] = opts.origin; + } else { + opts.headers.Origin = opts.origin; + } + } + if (parsedUrl.username || parsedUrl.password) { + opts.auth = `${parsedUrl.username}:${parsedUrl.password}`; + } + if (isIpcUrl) { + const parts = opts.path.split(":"); + opts.socketPath = parts[0]; + opts.path = parts[1]; + } + let req; + if (opts.followRedirects) { + if (websocket._redirects === 0) { + websocket._originalIpc = isIpcUrl; + websocket._originalSecure = isSecure; + websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host; + const headers = options && options.headers; + options = { ...options, headers: {} }; + if (headers) { + for (const [key2, value] of Object.entries(headers)) { + options.headers[key2.toLowerCase()] = value; + } + } + } else if (websocket.listenerCount("redirect") === 0) { + const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath; + if (!isSameHost || websocket._originalSecure && !isSecure) { + delete opts.headers.authorization; + delete opts.headers.cookie; + if (!isSameHost) + delete opts.headers.host; + opts.auth = void 0; + } + } + if (opts.auth && !options.headers.authorization) { + options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64"); + } + req = websocket._req = request(opts); + if (websocket._redirects) { + websocket.emit("redirect", websocket.url, req); + } + } else { + req = websocket._req = request(opts); + } + if (opts.timeout) { + req.on("timeout", () => { + abortHandshake(websocket, req, "Opening handshake has timed out"); + }); + } + req.on("error", (err) => { + if (req === null || req[kAborted]) + return; + req = websocket._req = null; + emitErrorAndClose(websocket, err); + }); + req.on("response", (res) => { + const location = res.headers.location; + const statusCode = res.statusCode; + if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) { + if (++websocket._redirects > opts.maxRedirects) { + abortHandshake(websocket, req, "Maximum redirects exceeded"); + return; + } + req.abort(); + let addr; + try { + addr = new URL(location, address); + } catch (e) { + const err = new SyntaxError(`Invalid URL: ${location}`); + emitErrorAndClose(websocket, err); + return; + } + initAsClient(websocket, addr, protocols, options); + } else if (!websocket.emit("unexpected-response", req, res)) { + abortHandshake( + websocket, + req, + `Unexpected server response: ${res.statusCode}` + ); + } + }); + req.on("upgrade", (res, socket, head) => { + websocket.emit("upgrade", res); + if (websocket.readyState !== WebSocket2.CONNECTING) + return; + req = websocket._req = null; + const upgrade = res.headers.upgrade; + if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") { + abortHandshake(websocket, socket, "Invalid Upgrade header"); + return; + } + const digest = createHash("sha1").update(key + GUID).digest("base64"); + if (res.headers["sec-websocket-accept"] !== digest) { + abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header"); + return; + } + const serverProt = res.headers["sec-websocket-protocol"]; + let protError; + if (serverProt !== void 0) { + if (!protocolSet.size) { + protError = "Server sent a subprotocol but none was requested"; + } else if (!protocolSet.has(serverProt)) { + protError = "Server sent an invalid subprotocol"; + } + } else if (protocolSet.size) { + protError = "Server sent no subprotocol"; + } + if (protError) { + abortHandshake(websocket, socket, protError); + return; + } + if (serverProt) + websocket._protocol = serverProt; + const secWebSocketExtensions = res.headers["sec-websocket-extensions"]; + if (secWebSocketExtensions !== void 0) { + if (!perMessageDeflate) { + const message = "Server sent a Sec-WebSocket-Extensions header but no extension was requested"; + abortHandshake(websocket, socket, message); + return; + } + let extensions; + try { + extensions = parse(secWebSocketExtensions); + } catch (err) { + const message = "Invalid Sec-WebSocket-Extensions header"; + abortHandshake(websocket, socket, message); + return; + } + const extensionNames = Object.keys(extensions); + if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) { + const message = "Server indicated an extension that was not requested"; + abortHandshake(websocket, socket, message); + return; + } + try { + perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]); + } catch (err) { + const message = "Invalid Sec-WebSocket-Extensions header"; + abortHandshake(websocket, socket, message); + return; + } + websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate; + } + websocket.setSocket(socket, head, { + allowSynchronousEvents: opts.allowSynchronousEvents, + generateMask: opts.generateMask, + maxPayload: opts.maxPayload, + skipUTF8Validation: opts.skipUTF8Validation + }); + }); + if (opts.finishRequest) { + opts.finishRequest(req, websocket); + } else { + req.end(); + } + } + function emitErrorAndClose(websocket, err) { + websocket._readyState = WebSocket2.CLOSING; + websocket._errorEmitted = true; + websocket.emit("error", err); + websocket.emitClose(); + } + function netConnect(options) { + options.path = options.socketPath; + return net.connect(options); + } + function tlsConnect(options) { + options.path = void 0; + if (!options.servername && options.servername !== "") { + options.servername = net.isIP(options.host) ? "" : options.host; + } + return tls.connect(options); + } + function abortHandshake(websocket, stream, message) { + websocket._readyState = WebSocket2.CLOSING; + const err = new Error(message); + Error.captureStackTrace(err, abortHandshake); + if (stream.setHeader) { + stream[kAborted] = true; + stream.abort(); + if (stream.socket && !stream.socket.destroyed) { + stream.socket.destroy(); + } + process.nextTick(emitErrorAndClose, websocket, err); + } else { + stream.destroy(err); + stream.once("error", websocket.emit.bind(websocket, "error")); + stream.once("close", websocket.emitClose.bind(websocket)); + } + } + function sendAfterClose(websocket, data, cb) { + if (data) { + const length = isBlob(data) ? data.size : toBuffer(data).length; + if (websocket._socket) + websocket._sender._bufferedBytes += length; + else + websocket._bufferedAmount += length; + } + if (cb) { + const err = new Error( + `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})` + ); + process.nextTick(cb, err); + } + } + function receiverOnConclude(code, reason) { + const websocket = this[kWebSocket]; + websocket._closeFrameReceived = true; + websocket._closeMessage = reason; + websocket._closeCode = code; + if (websocket._socket[kWebSocket] === void 0) + return; + websocket._socket.removeListener("data", socketOnData); + process.nextTick(resume, websocket._socket); + if (code === 1005) + websocket.close(); + else + websocket.close(code, reason); + } + function receiverOnDrain() { + const websocket = this[kWebSocket]; + if (!websocket.isPaused) + websocket._socket.resume(); + } + function receiverOnError(err) { + const websocket = this[kWebSocket]; + if (websocket._socket[kWebSocket] !== void 0) { + websocket._socket.removeListener("data", socketOnData); + process.nextTick(resume, websocket._socket); + websocket.close(err[kStatusCode]); + } + if (!websocket._errorEmitted) { + websocket._errorEmitted = true; + websocket.emit("error", err); + } + } + function receiverOnFinish() { + this[kWebSocket].emitClose(); + } + function receiverOnMessage(data, isBinary) { + this[kWebSocket].emit("message", data, isBinary); + } + function receiverOnPing(data) { + const websocket = this[kWebSocket]; + if (websocket._autoPong) + websocket.pong(data, !this._isServer, NOOP); + websocket.emit("ping", data); + } + function receiverOnPong(data) { + this[kWebSocket].emit("pong", data); + } + function resume(stream) { + stream.resume(); + } + function senderOnError(err) { + const websocket = this[kWebSocket]; + if (websocket.readyState === WebSocket2.CLOSED) + return; + if (websocket.readyState === WebSocket2.OPEN) { + websocket._readyState = WebSocket2.CLOSING; + setCloseTimer(websocket); + } + this._socket.end(); + if (!websocket._errorEmitted) { + websocket._errorEmitted = true; + websocket.emit("error", err); + } + } + function setCloseTimer(websocket) { + websocket._closeTimer = setTimeout( + websocket._socket.destroy.bind(websocket._socket), + closeTimeout + ); + } + function socketOnClose() { + const websocket = this[kWebSocket]; + this.removeListener("close", socketOnClose); + this.removeListener("data", socketOnData); + this.removeListener("end", socketOnEnd); + websocket._readyState = WebSocket2.CLOSING; + let chunk; + if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) { + websocket._receiver.write(chunk); + } + websocket._receiver.end(); + this[kWebSocket] = void 0; + clearTimeout(websocket._closeTimer); + if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) { + websocket.emitClose(); + } else { + websocket._receiver.on("error", receiverOnFinish); + websocket._receiver.on("finish", receiverOnFinish); + } + } + function socketOnData(chunk) { + if (!this[kWebSocket]._receiver.write(chunk)) { + this.pause(); + } + } + function socketOnEnd() { + const websocket = this[kWebSocket]; + websocket._readyState = WebSocket2.CLOSING; + websocket._receiver.end(); + this.end(); + } + function socketOnError() { + const websocket = this[kWebSocket]; + this.removeListener("error", socketOnError); + this.on("error", NOOP); + if (websocket) { + websocket._readyState = WebSocket2.CLOSING; + this.destroy(); + } + } + } +}); + +// ../testeranto/node_modules/ws/lib/subprotocol.js +var require_subprotocol = __commonJS({ + "../testeranto/node_modules/ws/lib/subprotocol.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var { tokenChars } = require_validation(); + function parse(header) { + const protocols = /* @__PURE__ */ new Set(); + let start = -1; + let end = -1; + let i = 0; + for (i; i < header.length; i++) { + const code = header.charCodeAt(i); + if (end === -1 && tokenChars[code] === 1) { + if (start === -1) + start = i; + } else if (i !== 0 && (code === 32 || code === 9)) { + if (end === -1 && start !== -1) + end = i; + } else if (code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) + end = i; + const protocol2 = header.slice(start, end); + if (protocols.has(protocol2)) { + throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`); + } + protocols.add(protocol2); + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } + if (start === -1 || end !== -1) { + throw new SyntaxError("Unexpected end of input"); + } + const protocol = header.slice(start, i); + if (protocols.has(protocol)) { + throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`); + } + protocols.add(protocol); + return protocols; + } + module.exports = { parse }; + } +}); + +// ../testeranto/node_modules/ws/lib/websocket-server.js +var require_websocket_server = __commonJS({ + "../testeranto/node_modules/ws/lib/websocket-server.js"(exports, module) { + "use strict"; + init_cjs_shim(); + var EventEmitter = __require("events"); + var http = __require("http"); + var { Duplex } = __require("stream"); + var { createHash } = __require("crypto"); + var extension = require_extension(); + var PerMessageDeflate = require_permessage_deflate(); + var subprotocol = require_subprotocol(); + var WebSocket2 = require_websocket(); + var { GUID, kWebSocket } = require_constants(); + var keyRegex = /^[+/0-9A-Za-z]{22}==$/; + var RUNNING = 0; + var CLOSING = 1; + var CLOSED = 2; + var WebSocketServer2 = class extends EventEmitter { + /** + * Create a `WebSocketServer` instance. + * + * @param {Object} options Configuration options + * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether + * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted + * multiple times in the same tick + * @param {Boolean} [options.autoPong=true] Specifies whether or not to + * automatically send a pong in response to a ping + * @param {Number} [options.backlog=511] The maximum length of the queue of + * pending connections + * @param {Boolean} [options.clientTracking=true] Specifies whether or not to + * track clients + * @param {Function} [options.handleProtocols] A hook to handle protocols + * @param {String} [options.host] The hostname where to bind the server + * @param {Number} [options.maxPayload=104857600] The maximum allowed message + * size + * @param {Boolean} [options.noServer=false] Enable no server mode + * @param {String} [options.path] Accept only connections matching this path + * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable + * permessage-deflate + * @param {Number} [options.port] The port where to bind the server + * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S + * server to use + * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or + * not to skip UTF-8 validation for text and close messages + * @param {Function} [options.verifyClient] A hook to reject connections + * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket` + * class to use. It must be the `WebSocket` class or class that extends it + * @param {Function} [callback] A listener for the `listening` event + */ + constructor(options, callback) { + super(); + options = { + allowSynchronousEvents: true, + autoPong: true, + maxPayload: 100 * 1024 * 1024, + skipUTF8Validation: false, + perMessageDeflate: false, + handleProtocols: null, + clientTracking: true, + verifyClient: null, + noServer: false, + backlog: null, + // use default (511 as implemented in net.js) + server: null, + host: null, + path: null, + port: null, + WebSocket: WebSocket2, + ...options + }; + if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) { + throw new TypeError( + 'One and only one of the "port", "server", or "noServer" options must be specified' + ); + } + if (options.port != null) { + this._server = http.createServer((req, res) => { + const body = http.STATUS_CODES[426]; + res.writeHead(426, { + "Content-Length": body.length, + "Content-Type": "text/plain" + }); + res.end(body); + }); + this._server.listen( + options.port, + options.host, + options.backlog, + callback + ); + } else if (options.server) { + this._server = options.server; + } + if (this._server) { + const emitConnection = this.emit.bind(this, "connection"); + this._removeListeners = addListeners(this._server, { + listening: this.emit.bind(this, "listening"), + error: this.emit.bind(this, "error"), + upgrade: (req, socket, head) => { + this.handleUpgrade(req, socket, head, emitConnection); + } + }); + } + if (options.perMessageDeflate === true) + options.perMessageDeflate = {}; + if (options.clientTracking) { + this.clients = /* @__PURE__ */ new Set(); + this._shouldEmitClose = false; + } + this.options = options; + this._state = RUNNING; + } + /** + * Returns the bound address, the address family name, and port of the server + * as reported by the operating system if listening on an IP socket. + * If the server is listening on a pipe or UNIX domain socket, the name is + * returned as a string. + * + * @return {(Object|String|null)} The address of the server + * @public + */ + address() { + if (this.options.noServer) { + throw new Error('The server is operating in "noServer" mode'); + } + if (!this._server) + return null; + return this._server.address(); + } + /** + * Stop the server from accepting new connections and emit the `'close'` event + * when all existing connections are closed. + * + * @param {Function} [cb] A one-time listener for the `'close'` event + * @public + */ + close(cb) { + if (this._state === CLOSED) { + if (cb) { + this.once("close", () => { + cb(new Error("The server is not running")); + }); + } + process.nextTick(emitClose, this); + return; + } + if (cb) + this.once("close", cb); + if (this._state === CLOSING) + return; + this._state = CLOSING; + if (this.options.noServer || this.options.server) { + if (this._server) { + this._removeListeners(); + this._removeListeners = this._server = null; + } + if (this.clients) { + if (!this.clients.size) { + process.nextTick(emitClose, this); + } else { + this._shouldEmitClose = true; + } + } else { + process.nextTick(emitClose, this); + } + } else { + const server = this._server; + this._removeListeners(); + this._removeListeners = this._server = null; + server.close(() => { + emitClose(this); + }); + } + } + /** + * See if a given request should be handled by this server instance. + * + * @param {http.IncomingMessage} req Request object to inspect + * @return {Boolean} `true` if the request is valid, else `false` + * @public + */ + shouldHandle(req) { + if (this.options.path) { + const index = req.url.indexOf("?"); + const pathname = index !== -1 ? req.url.slice(0, index) : req.url; + if (pathname !== this.options.path) + return false; + } + return true; + } + /** + * Handle a HTTP Upgrade request. + * + * @param {http.IncomingMessage} req The request object + * @param {Duplex} socket The network socket between the server and client + * @param {Buffer} head The first packet of the upgraded stream + * @param {Function} cb Callback + * @public + */ + handleUpgrade(req, socket, head, cb) { + socket.on("error", socketOnError); + const key = req.headers["sec-websocket-key"]; + const upgrade = req.headers.upgrade; + const version = +req.headers["sec-websocket-version"]; + if (req.method !== "GET") { + const message = "Invalid HTTP method"; + abortHandshakeOrEmitwsClientError(this, req, socket, 405, message); + return; + } + if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") { + const message = "Invalid Upgrade header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + if (key === void 0 || !keyRegex.test(key)) { + const message = "Missing or invalid Sec-WebSocket-Key header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + if (version !== 8 && version !== 13) { + const message = "Missing or invalid Sec-WebSocket-Version header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + if (!this.shouldHandle(req)) { + abortHandshake(socket, 400); + return; + } + const secWebSocketProtocol = req.headers["sec-websocket-protocol"]; + let protocols = /* @__PURE__ */ new Set(); + if (secWebSocketProtocol !== void 0) { + try { + protocols = subprotocol.parse(secWebSocketProtocol); + } catch (err) { + const message = "Invalid Sec-WebSocket-Protocol header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + } + const secWebSocketExtensions = req.headers["sec-websocket-extensions"]; + const extensions = {}; + if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) { + const perMessageDeflate = new PerMessageDeflate( + this.options.perMessageDeflate, + true, + this.options.maxPayload + ); + try { + const offers = extension.parse(secWebSocketExtensions); + if (offers[PerMessageDeflate.extensionName]) { + perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]); + extensions[PerMessageDeflate.extensionName] = perMessageDeflate; + } + } catch (err) { + const message = "Invalid or unacceptable Sec-WebSocket-Extensions header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + } + if (this.options.verifyClient) { + const info = { + origin: req.headers[`${version === 8 ? "sec-websocket-origin" : "origin"}`], + secure: !!(req.socket.authorized || req.socket.encrypted), + req + }; + if (this.options.verifyClient.length === 2) { + this.options.verifyClient(info, (verified, code, message, headers) => { + if (!verified) { + return abortHandshake(socket, code || 401, message, headers); + } + this.completeUpgrade( + extensions, + key, + protocols, + req, + socket, + head, + cb + ); + }); + return; + } + if (!this.options.verifyClient(info)) + return abortHandshake(socket, 401); + } + this.completeUpgrade(extensions, key, protocols, req, socket, head, cb); + } + /** + * Upgrade the connection to WebSocket. + * + * @param {Object} extensions The accepted extensions + * @param {String} key The value of the `Sec-WebSocket-Key` header + * @param {Set} protocols The subprotocols + * @param {http.IncomingMessage} req The request object + * @param {Duplex} socket The network socket between the server and client + * @param {Buffer} head The first packet of the upgraded stream + * @param {Function} cb Callback + * @throws {Error} If called more than once with the same socket + * @private + */ + completeUpgrade(extensions, key, protocols, req, socket, head, cb) { + if (!socket.readable || !socket.writable) + return socket.destroy(); + if (socket[kWebSocket]) { + throw new Error( + "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration" + ); + } + if (this._state > RUNNING) + return abortHandshake(socket, 503); + const digest = createHash("sha1").update(key + GUID).digest("base64"); + const headers = [ + "HTTP/1.1 101 Switching Protocols", + "Upgrade: websocket", + "Connection: Upgrade", + `Sec-WebSocket-Accept: ${digest}` + ]; + const ws = new this.options.WebSocket(null, void 0, this.options); + if (protocols.size) { + const protocol = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value; + if (protocol) { + headers.push(`Sec-WebSocket-Protocol: ${protocol}`); + ws._protocol = protocol; + } + } + if (extensions[PerMessageDeflate.extensionName]) { + const params = extensions[PerMessageDeflate.extensionName].params; + const value = extension.format({ + [PerMessageDeflate.extensionName]: [params] + }); + headers.push(`Sec-WebSocket-Extensions: ${value}`); + ws._extensions = extensions; + } + this.emit("headers", headers, req); + socket.write(headers.concat("\r\n").join("\r\n")); + socket.removeListener("error", socketOnError); + ws.setSocket(socket, head, { + allowSynchronousEvents: this.options.allowSynchronousEvents, + maxPayload: this.options.maxPayload, + skipUTF8Validation: this.options.skipUTF8Validation + }); + if (this.clients) { + this.clients.add(ws); + ws.on("close", () => { + this.clients.delete(ws); + if (this._shouldEmitClose && !this.clients.size) { + process.nextTick(emitClose, this); + } + }); + } + cb(ws, req); + } + }; + module.exports = WebSocketServer2; + function addListeners(server, map) { + for (const event of Object.keys(map)) + server.on(event, map[event]); + return function removeListeners() { + for (const event of Object.keys(map)) { + server.removeListener(event, map[event]); + } + }; + } + function emitClose(server) { + server._state = CLOSED; + server.emit("close"); + } + function socketOnError() { + this.destroy(); + } + function abortHandshake(socket, code, message, headers) { + message = message || http.STATUS_CODES[code]; + headers = { + Connection: "close", + "Content-Type": "text/html", + "Content-Length": Buffer.byteLength(message), + ...headers + }; + socket.once("finish", socket.destroy); + socket.end( + `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r +` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message + ); + } + function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) { + if (server.listenerCount("wsClientError")) { + const err = new Error(message); + Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError); + server.emit("wsClientError", err, socket, req); + } else { + abortHandshake(socket, code, message); + } + } + } +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/NodeWebSocketTransport.js +init_cjs_shim(); + +// ../testeranto/node_modules/ws/wrapper.mjs +init_cjs_shim(); +var import_stream = __toESM(require_stream(), 1); +var import_receiver = __toESM(require_receiver(), 1); +var import_sender = __toESM(require_sender(), 1); +var import_websocket = __toESM(require_websocket(), 1); +var import_websocket_server = __toESM(require_websocket_server(), 1); +var wrapper_default = import_websocket.default; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/node/NodeWebSocketTransport.js +var NodeWebSocketTransport = class { + static create(url, headers) { + return new Promise((resolve, reject) => { + const ws = new wrapper_default(url, [], { + followRedirects: true, + perMessageDeflate: false, + // @ts-expect-error https://github.com/websockets/ws/blob/master/doc/ws.md#new-websocketaddress-protocols-options + allowSynchronousEvents: false, + maxPayload: 256 * 1024 * 1024, + // 256Mb + headers: { + "User-Agent": `Puppeteer ${packageVersion}`, + ...headers + } + }); + ws.addEventListener("open", () => { + return resolve(new NodeWebSocketTransport(ws)); + }); + ws.addEventListener("error", reject); + }); + } + #ws; + onmessage; + onclose; + constructor(ws) { + this.#ws = ws; + this.#ws.addEventListener("message", (event) => { + if (this.onmessage) { + this.onmessage.call(null, event.data); + } + }); + this.#ws.addEventListener("close", () => { + if (this.onclose) { + this.onclose.call(null); + } + }); + this.#ws.addEventListener("error", () => { + }); + } + send(message) { + this.#ws.send(message); + } + close() { + this.#ws.close(); + } +}; + +export { + NodeWebSocketTransport +}; +/*! Bundled license information: + +puppeteer-core/lib/esm/puppeteer/node/NodeWebSocketTransport.js: + (** + * @license + * Copyright 2018 Google Inc. + * SPDX-License-Identifier: Apache-2.0 + *) +*/ diff --git a/docs/node/chunk-RBWPBMY4.mjs b/docs/node/chunk-RBWPBMY4.mjs new file mode 100644 index 00000000..beeb14ce --- /dev/null +++ b/docs/node/chunk-RBWPBMY4.mjs @@ -0,0 +1,12045 @@ +import { createRequire } from 'module';const require = createRequire(import.meta.url); +import { + packageVersion +} from "./chunk-VDOS7AVZ.mjs"; +import { + __privateAdd, + __privateGet, + __privateSet, + __publicField, + init_cjs_shim +} from "./chunk-THMF2HPO.mjs"; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/third_party/rxjs/rxjs.js +init_cjs_shim(); +var extendStatics = function(d, b) { + extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) { + d2.__proto__ = b2; + } || function(d2, b2) { + for (var p in b2) + if (Object.prototype.hasOwnProperty.call(b2, p)) + d2[p] = b2[p]; + }; + return extendStatics(d, b); +}; +function __extends(d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +} +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve) { + resolve(value); + }); + } + return new (P || (P = Promise))(function(resolve, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } + } + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} +function __generator(thisArg, body) { + var _ = { label: 0, sent: function() { + if (t[0] & 1) + throw t[1]; + return t[1]; + }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { + return this; + }), g; + function verb(n) { + return function(v) { + return step([n, v]); + }; + } + function step(op) { + if (f) + throw new TypeError("Generator is already executing."); + while (g && (g = 0, op[0] && (_ = 0)), _) + try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) + return t; + if (y = 0, t) + op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: + case 1: + t = op; + break; + case 4: + _.label++; + return { value: op[1], done: false }; + case 5: + _.label++; + y = op[1]; + op = [0]; + continue; + case 7: + op = _.ops.pop(); + _.trys.pop(); + continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { + _ = 0; + continue; + } + if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { + _.label = op[1]; + break; + } + if (op[0] === 6 && _.label < t[1]) { + _.label = t[1]; + t = op; + break; + } + if (t && _.label < t[2]) { + _.label = t[2]; + _.ops.push(op); + break; + } + if (t[2]) + _.ops.pop(); + _.trys.pop(); + continue; + } + op = body.call(thisArg, _); + } catch (e) { + op = [6, e]; + y = 0; + } finally { + f = t = 0; + } + if (op[0] & 5) + throw op[1]; + return { value: op[0] ? op[1] : void 0, done: true }; + } +} +function __values(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) + return m.call(o); + if (o && typeof o.length === "number") + return { + next: function() { + if (o && i >= o.length) + o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +} +function __read(o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) + return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) + ar.push(r.value); + } catch (error) { + e = { error }; + } finally { + try { + if (r && !r.done && (m = i["return"])) + m.call(i); + } finally { + if (e) + throw e.error; + } + } + return ar; +} +function __spreadArray(to, from2, pack) { + if (pack || arguments.length === 2) + for (var i = 0, l = from2.length, ar; i < l; i++) { + if (ar || !(i in from2)) { + if (!ar) + ar = Array.prototype.slice.call(from2, 0, i); + ar[i] = from2[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from2)); +} +function __await(v) { + return this instanceof __await ? (this.v = v, this) : new __await(v); +} +function __asyncGenerator(thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) + throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() { + return this; + }, i; + function verb(n) { + if (g[n]) + i[n] = function(v) { + return new Promise(function(a, b) { + q.push([n, v, a, b]) > 1 || resume(n, v); + }); + }; + } + function resume(n, v) { + try { + step(g[n](v)); + } catch (e) { + settle(q[0][3], e); + } + } + function step(r) { + r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); + } + function fulfill(value) { + resume("next", value); + } + function reject(value) { + resume("throw", value); + } + function settle(f, v) { + if (f(v), q.shift(), q.length) + resume(q[0][0], q[0][1]); + } +} +function __asyncValues(o) { + if (!Symbol.asyncIterator) + throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() { + return this; + }, i); + function verb(n) { + i[n] = o[n] && function(v) { + return new Promise(function(resolve, reject) { + v = o[n](v), settle(resolve, reject, v.done, v.value); + }); + }; + } + function settle(resolve, reject, d, v) { + Promise.resolve(v).then(function(v2) { + resolve({ value: v2, done: d }); + }, 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; +} +var UnsubscriptionError = createErrorClass(function(_super) { + return function UnsubscriptionErrorImpl(errors) { + _super(this); + this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) { + return i + 1 + ") " + err.toString(); + }).join("\n ") : ""; + this.name = "UnsubscriptionError"; + this.errors = errors; + }; +}); +function arrRemove(arr, item) { + if (arr) { + var index = arr.indexOf(item); + 0 <= index && arr.splice(index, 1); + } +} +var Subscription = function() { + function Subscription2(initialTeardown) { + this.initialTeardown = initialTeardown; + this.closed = false; + this._parentage = null; + this._finalizers = null; + } + Subscription2.prototype.unsubscribe = function() { + var e_1, _a, e_2, _b; + 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 && (_a = _parentage_1.return)) + _a.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 (e) { + errors = e instanceof UnsubscriptionError ? e.errors : [e]; + } + } + 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; + try { + execFinalizer(finalizer); + } catch (err) { + errors = errors !== null && errors !== void 0 ? errors : []; + if (err instanceof UnsubscriptionError) { + errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors)); + } else { + errors.push(err); + } + } + } + } catch (e_2_1) { + e_2 = { error: e_2_1 }; + } finally { + try { + if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) + _b.call(_finalizers_1); + } finally { + if (e_2) + throw e_2.error; + } + } + } + if (errors) { + throw new UnsubscriptionError(errors); + } + } + }; + Subscription2.prototype.add = function(teardown) { + var _a; + if (teardown && teardown !== this) { + if (this.closed) { + execFinalizer(teardown); + } else { + if (teardown instanceof Subscription2) { + if (teardown.closed || teardown._hasParent(this)) { + return; + } + teardown._addParent(this); + } + (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown); + } + } + }; + Subscription2.prototype._hasParent = function(parent) { + var _parentage = this._parentage; + return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent); + }; + Subscription2.prototype._addParent = function(parent) { + var _parentage = this._parentage; + this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent; + }; + Subscription2.prototype._removeParent = function(parent) { + var _parentage = this._parentage; + if (_parentage === parent) { + this._parentage = null; + } else if (Array.isArray(_parentage)) { + arrRemove(_parentage, parent); + } + }; + Subscription2.prototype.remove = function(teardown) { + var _finalizers = this._finalizers; + _finalizers && arrRemove(_finalizers, teardown); + if (teardown instanceof Subscription2) { + teardown._removeParent(this); + } + }; + Subscription2.EMPTY = function() { + var empty = new Subscription2(); + empty.closed = true; + return empty; + }(); + return Subscription2; +}(); +var EMPTY_SUBSCRIPTION = Subscription.EMPTY; +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(); + } +} +var config = { + onUnhandledError: null, + onStoppedNotification: null, + Promise: void 0, + useDeprecatedSynchronousErrorHandling: false, + useDeprecatedNextContext: false +}; +var timeoutProvider = { + setTimeout: function(handler, timeout2) { + var args = []; + for (var _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + var delegate = timeoutProvider.delegate; + if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) { + return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout2], __read(args))); + } + return setTimeout.apply(void 0, __spreadArray([handler, timeout2], __read(args))); + }, + clearTimeout: function(handle) { + var delegate = timeoutProvider.delegate; + return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle); + }, + delegate: void 0 +}; +function reportUnhandledError(err) { + timeoutProvider.setTimeout(function() { + var onUnhandledError = config.onUnhandledError; + if (onUnhandledError) { + onUnhandledError(err); + } else { + throw err; + } + }); +} +function noop() { +} +var COMPLETE_NOTIFICATION = function() { + return createNotification("C", void 0, void 0); +}(); +function errorNotification(error) { + return createNotification("E", void 0, error); +} +function nextNotification(value) { + return createNotification("N", value, void 0); +} +function createNotification(kind, value, error) { + return { + kind, + value, + error + }; +} +var context = null; +function errorContext(cb) { + if (config.useDeprecatedSynchronousErrorHandling) { + var isRoot = !context; + if (isRoot) { + context = { errorThrown: false, error: null }; + } + cb(); + if (isRoot) { + var _a = context, errorThrown = _a.errorThrown, error = _a.error; + context = null; + if (errorThrown) { + throw error; + } + } + } else { + cb(); + } +} +function captureError(err) { + if (config.useDeprecatedSynchronousErrorHandling && context) { + context.errorThrown = true; + context.error = err; + } +} +var Subscriber = function(_super) { + __extends(Subscriber2, _super); + function Subscriber2(destination) { + var _this = _super.call(this) || this; + _this.isStopped = false; + if (destination) { + _this.destination = destination; + if (isSubscription(destination)) { + destination.add(_this); + } + } else { + _this.destination = EMPTY_OBSERVER; + } + return _this; + } + Subscriber2.create = function(next, error, complete) { + return new SafeSubscriber(next, error, complete); + }; + Subscriber2.prototype.next = function(value) { + if (this.isStopped) { + handleStoppedNotification(nextNotification(value), this); + } else { + this._next(value); + } + }; + Subscriber2.prototype.error = function(err) { + if (this.isStopped) { + handleStoppedNotification(errorNotification(err), this); + } else { + this.isStopped = true; + this._error(err); + } + }; + Subscriber2.prototype.complete = function() { + if (this.isStopped) { + handleStoppedNotification(COMPLETE_NOTIFICATION, this); + } else { + this.isStopped = true; + this._complete(); + } + }; + Subscriber2.prototype.unsubscribe = function() { + if (!this.closed) { + this.isStopped = true; + _super.prototype.unsubscribe.call(this); + this.destination = null; + } + }; + Subscriber2.prototype._next = function(value) { + this.destination.next(value); + }; + Subscriber2.prototype._error = function(err) { + try { + this.destination.error(err); + } finally { + this.unsubscribe(); + } + }; + Subscriber2.prototype._complete = function() { + try { + this.destination.complete(); + } finally { + this.unsubscribe(); + } + }; + return Subscriber2; +}(Subscription); +var _bind = Function.prototype.bind; +function bind(fn, thisArg) { + return _bind.call(fn, thisArg); +} +var ConsumerObserver = function() { + function ConsumerObserver2(partialObserver) { + this.partialObserver = partialObserver; + } + ConsumerObserver2.prototype.next = function(value) { + var partialObserver = this.partialObserver; + if (partialObserver.next) { + try { + partialObserver.next(value); + } catch (error) { + handleUnhandledError(error); + } + } + }; + ConsumerObserver2.prototype.error = function(err) { + var partialObserver = this.partialObserver; + if (partialObserver.error) { + try { + partialObserver.error(err); + } catch (error) { + handleUnhandledError(error); + } + } else { + handleUnhandledError(err); + } + }; + ConsumerObserver2.prototype.complete = function() { + var partialObserver = this.partialObserver; + if (partialObserver.complete) { + try { + partialObserver.complete(); + } catch (error) { + handleUnhandledError(error); + } + } + }; + return ConsumerObserver2; +}(); +var SafeSubscriber = function(_super) { + __extends(SafeSubscriber2, _super); + function SafeSubscriber2(observerOrNext, error, complete) { + var _this = _super.call(this) || this; + var partialObserver; + if (isFunction(observerOrNext) || !observerOrNext) { + partialObserver = { + next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0, + error: error !== null && error !== void 0 ? error : void 0, + complete: complete !== null && complete !== void 0 ? complete : void 0 + }; + } else { + var context_1; + if (_this && config.useDeprecatedNextContext) { + context_1 = Object.create(observerOrNext); + context_1.unsubscribe = function() { + return _this.unsubscribe(); + }; + partialObserver = { + next: observerOrNext.next && bind(observerOrNext.next, context_1), + error: observerOrNext.error && bind(observerOrNext.error, context_1), + complete: observerOrNext.complete && bind(observerOrNext.complete, context_1) + }; + } else { + partialObserver = observerOrNext; + } + } + _this.destination = new ConsumerObserver(partialObserver); + return _this; + } + return SafeSubscriber2; +}(Subscriber); +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); + }); +} +var EMPTY_OBSERVER = { + closed: true, + next: noop, + error: defaultErrorHandler, + complete: noop +}; +var observable = function() { + return typeof Symbol === "function" && Symbol.observable || "@@observable"; +}(); +function identity(x) { + return x; +} +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(prev, fn) { + return fn(prev); + }, input); + }; +} +var Observable = function() { + function Observable2(subscribe) { + if (subscribe) { + this._subscribe = subscribe; + } + } + Observable2.prototype.lift = function(operator) { + var observable2 = new Observable2(); + observable2.source = this; + observable2.operator = operator; + return observable2; + }; + Observable2.prototype.subscribe = function(observerOrNext, error, complete) { + var _this = this; + var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete); + errorContext(function() { + var _a = _this, operator = _a.operator, source2 = _a.source; + subscriber.add(operator ? operator.call(subscriber, source2) : source2 ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber)); + }); + return subscriber; + }; + Observable2.prototype._trySubscribe = function(sink) { + try { + return this._subscribe(sink); + } catch (err) { + sink.error(err); + } + }; + Observable2.prototype.forEach = function(next, promiseCtor) { + var _this = this; + promiseCtor = getPromiseCtor(promiseCtor); + return new promiseCtor(function(resolve, reject) { + var subscriber = new SafeSubscriber({ + next: function(value) { + try { + next(value); + } catch (err) { + reject(err); + subscriber.unsubscribe(); + } + }, + error: reject, + complete: resolve + }); + _this.subscribe(subscriber); + }); + }; + Observable2.prototype._subscribe = function(subscriber) { + var _a; + return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber); + }; + Observable2.prototype[observable] = function() { + return this; + }; + Observable2.prototype.pipe = function() { + var operations = []; + for (var _i = 0; _i < arguments.length; _i++) { + operations[_i] = arguments[_i]; + } + return pipeFromArray(operations)(this); + }; + Observable2.prototype.toPromise = function(promiseCtor) { + var _this = this; + promiseCtor = getPromiseCtor(promiseCtor); + return new promiseCtor(function(resolve, reject) { + var value; + _this.subscribe(function(x) { + return value = x; + }, function(err) { + return reject(err); + }, function() { + return resolve(value); + }); + }); + }; + Observable2.create = function(subscribe) { + return new Observable2(subscribe); + }; + return Observable2; +}(); +function getPromiseCtor(promiseCtor) { + var _a; + return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : 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); +} +var OperatorSubscriber = function(_super) { + __extends(OperatorSubscriber2, _super); + function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) { + var _this = _super.call(this, destination) || this; + _this.onFinalize = onFinalize; + _this.shouldUnsubscribe = shouldUnsubscribe; + _this._next = onNext ? function(value) { + try { + onNext(value); + } catch (err) { + destination.error(err); + } + } : _super.prototype._next; + _this._error = onError ? function(err) { + try { + onError(err); + } catch (err2) { + destination.error(err2); + } finally { + this.unsubscribe(); + } + } : _super.prototype._error; + _this._complete = onComplete ? function() { + try { + onComplete(); + } catch (err) { + destination.error(err); + } finally { + this.unsubscribe(); + } + } : _super.prototype._complete; + return _this; + } + OperatorSubscriber2.prototype.unsubscribe = function() { + var _a; + if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) { + var closed_1 = this.closed; + _super.prototype.unsubscribe.call(this); + !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this)); + } + }; + return OperatorSubscriber2; +}(Subscriber); +var ObjectUnsubscribedError = createErrorClass(function(_super) { + return function ObjectUnsubscribedErrorImpl() { + _super(this); + this.name = "ObjectUnsubscribedError"; + this.message = "object unsubscribed"; + }; +}); +var Subject = function(_super) { + __extends(Subject2, _super); + function Subject2() { + var _this = _super.call(this) || this; + _this.closed = false; + _this.currentObservers = null; + _this.observers = []; + _this.isStopped = false; + _this.hasError = false; + _this.thrownError = null; + return _this; + } + Subject2.prototype.lift = function(operator) { + var subject = new AnonymousSubject(this, this); + subject.operator = operator; + return subject; + }; + Subject2.prototype._throwIfClosed = function() { + if (this.closed) { + throw new ObjectUnsubscribedError(); + } + }; + Subject2.prototype.next = function(value) { + var _this = this; + errorContext(function() { + var e_1, _a; + _this._throwIfClosed(); + if (!_this.isStopped) { + if (!_this.currentObservers) { + _this.currentObservers = Array.from(_this.observers); + } + try { + for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) { + var observer = _c.value; + observer.next(value); + } + } catch (e_1_1) { + e_1 = { error: e_1_1 }; + } finally { + try { + if (_c && !_c.done && (_a = _b.return)) + _a.call(_b); + } finally { + if (e_1) + throw e_1.error; + } + } + } + }); + }; + Subject2.prototype.error = function(err) { + var _this = this; + errorContext(function() { + _this._throwIfClosed(); + if (!_this.isStopped) { + _this.hasError = _this.isStopped = true; + _this.thrownError = err; + var observers = _this.observers; + while (observers.length) { + observers.shift().error(err); + } + } + }); + }; + Subject2.prototype.complete = function() { + var _this = this; + errorContext(function() { + _this._throwIfClosed(); + if (!_this.isStopped) { + _this.isStopped = true; + var observers = _this.observers; + while (observers.length) { + observers.shift().complete(); + } + } + }); + }; + Subject2.prototype.unsubscribe = function() { + this.isStopped = this.closed = true; + this.observers = this.currentObservers = null; + }; + Object.defineProperty(Subject2.prototype, "observed", { + get: function() { + var _a; + return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0; + }, + enumerable: false, + configurable: true + }); + Subject2.prototype._trySubscribe = function(subscriber) { + this._throwIfClosed(); + return _super.prototype._trySubscribe.call(this, subscriber); + }; + Subject2.prototype._subscribe = function(subscriber) { + this._throwIfClosed(); + this._checkFinalizedStatuses(subscriber); + return this._innerSubscribe(subscriber); + }; + Subject2.prototype._innerSubscribe = function(subscriber) { + var _this = this; + var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers; + if (hasError || isStopped) { + return EMPTY_SUBSCRIPTION; + } + this.currentObservers = null; + observers.push(subscriber); + return new Subscription(function() { + _this.currentObservers = null; + arrRemove(observers, subscriber); + }); + }; + Subject2.prototype._checkFinalizedStatuses = function(subscriber) { + var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped; + if (hasError) { + subscriber.error(thrownError); + } else if (isStopped) { + subscriber.complete(); + } + }; + Subject2.prototype.asObservable = function() { + var observable2 = new Observable(); + observable2.source = this; + return observable2; + }; + Subject2.create = function(destination, source2) { + return new AnonymousSubject(destination, source2); + }; + return Subject2; +}(Observable); +var AnonymousSubject = function(_super) { + __extends(AnonymousSubject2, _super); + function AnonymousSubject2(destination, source2) { + var _this = _super.call(this) || this; + _this.destination = destination; + _this.source = source2; + return _this; + } + AnonymousSubject2.prototype.next = function(value) { + var _a, _b; + (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value); + }; + AnonymousSubject2.prototype.error = function(err) { + var _a, _b; + (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err); + }; + AnonymousSubject2.prototype.complete = function() { + var _a, _b; + (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a); + }; + AnonymousSubject2.prototype._subscribe = function(subscriber) { + var _a, _b; + return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION; + }; + return AnonymousSubject2; +}(Subject); +var dateTimestampProvider = { + now: function() { + return (dateTimestampProvider.delegate || Date).now(); + }, + delegate: void 0 +}; +var ReplaySubject = function(_super) { + __extends(ReplaySubject2, _super); + function ReplaySubject2(_bufferSize, _windowTime, _timestampProvider) { + if (_bufferSize === void 0) { + _bufferSize = Infinity; + } + if (_windowTime === void 0) { + _windowTime = Infinity; + } + if (_timestampProvider === void 0) { + _timestampProvider = dateTimestampProvider; + } + var _this = _super.call(this) || this; + _this._bufferSize = _bufferSize; + _this._windowTime = _windowTime; + _this._timestampProvider = _timestampProvider; + _this._buffer = []; + _this._infiniteTimeWindow = true; + _this._infiniteTimeWindow = _windowTime === Infinity; + _this._bufferSize = Math.max(1, _bufferSize); + _this._windowTime = Math.max(1, _windowTime); + return _this; + } + ReplaySubject2.prototype.next = function(value) { + var _a = this, isStopped = _a.isStopped, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow, _timestampProvider = _a._timestampProvider, _windowTime = _a._windowTime; + if (!isStopped) { + _buffer.push(value); + !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime); + } + this._trimBuffer(); + _super.prototype.next.call(this, value); + }; + ReplaySubject2.prototype._subscribe = function(subscriber) { + this._throwIfClosed(); + this._trimBuffer(); + var subscription = this._innerSubscribe(subscriber); + var _a = this, _infiniteTimeWindow = _a._infiniteTimeWindow, _buffer = _a._buffer; + var copy = _buffer.slice(); + for (var i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) { + subscriber.next(copy[i]); + } + this._checkFinalizedStatuses(subscriber); + return subscription; + }; + ReplaySubject2.prototype._trimBuffer = function() { + var _a = this, _bufferSize = _a._bufferSize, _timestampProvider = _a._timestampProvider, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow; + var adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize; + _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize); + if (!_infiniteTimeWindow) { + var now = _timestampProvider.now(); + var last2 = 0; + for (var i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) { + last2 = i; + } + last2 && _buffer.splice(0, last2 + 1); + } + }; + return ReplaySubject2; +}(Subject); +var Action = function(_super) { + __extends(Action2, _super); + function Action2(scheduler, work) { + return _super.call(this) || this; + } + Action2.prototype.schedule = function(state, delay2) { + if (delay2 === void 0) { + delay2 = 0; + } + return this; + }; + return Action2; +}(Subscription); +var intervalProvider = { + setInterval: function(handler, timeout2) { + var args = []; + for (var _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + var delegate = intervalProvider.delegate; + if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) { + return delegate.setInterval.apply(delegate, __spreadArray([handler, timeout2], __read(args))); + } + return setInterval.apply(void 0, __spreadArray([handler, timeout2], __read(args))); + }, + clearInterval: function(handle) { + var delegate = intervalProvider.delegate; + return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle); + }, + delegate: void 0 +}; +var AsyncAction = function(_super) { + __extends(AsyncAction2, _super); + function AsyncAction2(scheduler, work) { + var _this = _super.call(this, scheduler, work) || this; + _this.scheduler = scheduler; + _this.work = work; + _this.pending = false; + return _this; + } + AsyncAction2.prototype.schedule = function(state, delay2) { + var _a; + if (delay2 === void 0) { + delay2 = 0; + } + if (this.closed) { + return this; + } + this.state = state; + var id = this.id; + var scheduler = this.scheduler; + if (id != null) { + this.id = this.recycleAsyncId(scheduler, id, delay2); + } + this.pending = true; + this.delay = delay2; + this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay2); + return this; + }; + AsyncAction2.prototype.requestAsyncId = function(scheduler, _id, delay2) { + if (delay2 === void 0) { + delay2 = 0; + } + return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay2); + }; + AsyncAction2.prototype.recycleAsyncId = function(_scheduler, id, delay2) { + if (delay2 === void 0) { + delay2 = 0; + } + if (delay2 != null && this.delay === delay2 && this.pending === false) { + return id; + } + if (id != null) { + intervalProvider.clearInterval(id); + } + return void 0; + }; + AsyncAction2.prototype.execute = function(state, delay2) { + if (this.closed) { + return new Error("executing a cancelled action"); + } + this.pending = false; + var error = this._execute(state, delay2); + if (error) { + return error; + } else if (this.pending === false && this.id != null) { + this.id = this.recycleAsyncId(this.scheduler, this.id, null); + } + }; + AsyncAction2.prototype._execute = function(state, _delay) { + var errored = false; + var errorValue; + try { + this.work(state); + } catch (e) { + errored = true; + errorValue = e ? e : new Error("Scheduled action threw falsy error"); + } + if (errored) { + this.unsubscribe(); + return errorValue; + } + }; + AsyncAction2.prototype.unsubscribe = function() { + if (!this.closed) { + var _a = this, id = _a.id, scheduler = _a.scheduler; + var actions = scheduler.actions; + this.work = this.state = this.scheduler = null; + this.pending = false; + arrRemove(actions, this); + if (id != null) { + this.id = this.recycleAsyncId(scheduler, id, null); + } + this.delay = null; + _super.prototype.unsubscribe.call(this); + } + }; + return AsyncAction2; +}(Action); +var Scheduler = function() { + function Scheduler2(schedulerActionCtor, now) { + if (now === void 0) { + now = Scheduler2.now; + } + this.schedulerActionCtor = schedulerActionCtor; + this.now = now; + } + Scheduler2.prototype.schedule = function(work, delay2, state) { + if (delay2 === void 0) { + delay2 = 0; + } + return new this.schedulerActionCtor(this, work).schedule(state, delay2); + }; + Scheduler2.now = dateTimestampProvider.now; + return Scheduler2; +}(); +var AsyncScheduler = function(_super) { + __extends(AsyncScheduler2, _super); + function AsyncScheduler2(SchedulerAction, now) { + if (now === void 0) { + now = Scheduler.now; + } + var _this = _super.call(this, SchedulerAction, now) || this; + _this.actions = []; + _this._active = false; + return _this; + } + AsyncScheduler2.prototype.flush = function(action) { + var actions = this.actions; + if (this._active) { + actions.push(action); + return; + } + var error; + this._active = true; + do { + if (error = action.execute(action.state, action.delay)) { + break; + } + } while (action = actions.shift()); + this._active = false; + if (error) { + while (action = actions.shift()) { + action.unsubscribe(); + } + throw error; + } + }; + return AsyncScheduler2; +}(Scheduler); +var asyncScheduler = new AsyncScheduler(AsyncAction); +var async = asyncScheduler; +var EMPTY = new Observable(function(subscriber) { + return subscriber.complete(); +}); +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; +} +var isArrayLike = function(x) { + return x && typeof x.length === "number" && typeof x !== "function"; +}; +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; +} +var iterator = getSymbolIterator(); +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, _a, value, done; + return __generator(this, function(_b) { + switch (_b.label) { + case 0: + reader = readableStream.getReader(); + _b.label = 1; + case 1: + _b.trys.push([1, , 9, 10]); + _b.label = 2; + case 2: + if (false) + return [3, 8]; + return [4, __await(reader.read())]; + case 3: + _a = _b.sent(), value = _a.value, done = _a.done; + if (!done) + return [3, 5]; + return [4, __await(void 0)]; + case 4: + return [2, _b.sent()]; + case 5: + return [4, __await(value)]; + case 6: + return [4, _b.sent()]; + case 7: + _b.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 i = 0; i < array.length && !subscriber.closed; i++) { + subscriber.next(array[i]); + } + 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, _a; + 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 && (_a = iterable_1.return)) + _a.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, _a; + return __awaiter(this, void 0, void 0, function() { + var value, e_2_1; + return __generator(this, function(_b) { + switch (_b.label) { + case 0: + _b.trys.push([0, 5, 6, 11]); + asyncIterable_1 = __asyncValues(asyncIterable); + _b.label = 1; + case 1: + return [4, asyncIterable_1.next()]; + case 2: + if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) + return [3, 4]; + value = asyncIterable_1_1.value; + subscriber.next(value); + if (subscriber.closed) { + return [2]; + } + _b.label = 3; + case 3: + return [3, 1]; + case 4: + return [3, 11]; + case 5: + e_2_1 = _b.sent(); + e_2 = { error: e_2_1 }; + return [3, 11]; + case 6: + _b.trys.push([6, , 9, 10]); + if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) + return [3, 8]; + return [4, _a.call(asyncIterable_1)]; + case 7: + _b.sent(); + _b.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 i = 0; + return scheduler.schedule(function() { + if (i === input.length) { + subscriber.complete(); + } else { + subscriber.next(input[i++]); + 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 _a; + var value; + var done; + try { + _a = iterator2.next(), value = _a.value, done = _a.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); +} +var EmptyError = createErrorClass(function(_super) { + return function EmptyErrorImpl() { + _super(this); + this.name = "EmptyError"; + this.message = "no elements in sequence"; + }; +}); +function lastValueFrom(source2, config2) { + var hasConfig = typeof config2 === "object"; + return new Promise(function(resolve, reject) { + var _hasValue = false; + var _value; + source2.subscribe({ + next: function(value) { + _value = value; + _hasValue = true; + }, + error: reject, + complete: function() { + if (_hasValue) { + resolve(_value); + } else if (hasConfig) { + resolve(config2.defaultValue); + } else { + reject(new EmptyError()); + } + } + }); + }); +} +function firstValueFrom(source2, config2) { + var hasConfig = typeof config2 === "object"; + return new Promise(function(resolve, reject) { + var subscriber = new SafeSubscriber({ + next: function(value) { + resolve(value); + subscriber.unsubscribe(); + }, + error: reject, + complete: function() { + if (hasConfig) { + resolve(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 index = 0; + source2.subscribe(createOperatorSubscriber(subscriber, function(value) { + subscriber.next(project.call(thisArg, value, index++)); + })); + }); +} +var isArray = Array.isArray; +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); + }); +} +var isArray2 = Array.isArray; +var getPrototypeOf = Object.getPrototypeOf; +var objectProto = Object.prototype; +var getKeys = Object.keys; +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, i) { + return result[key] = values[i], 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 _a = argsArgArrayOrObject(args), observables = _a.args, keys = _a.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(i2) { + maybeSchedule(scheduler, function() { + var source2 = from(observables[i2], scheduler); + var hasFirstValue = false; + source2.subscribe(createOperatorSubscriber(subscriber, function(value) { + values[i2] = value; + if (!hasFirstValue) { + hasFirstValue = true; + remainingFirstValues--; + } + if (!remainingFirstValues) { + subscriber.next(valueTransform(values.slice())); + } + }, function() { + if (!--active) { + subscriber.complete(); + } + })); + }, subscriber); + }; + for (var i = 0; i < length; i++) { + _loop_1(i); + } + }, 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 index = 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, index++)).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(a, i) { + return map(function(b, ii) { + return resultSelector(a, b, i, ii); + })(innerFrom(project(a, i))); + }, 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); + }); +} +var nodeEventEmitterMethods = ["addListener", "removeListener"]; +var eventTargetMethods = ["addEventListener", "removeEventListener"]; +var jqueryMethods = ["on", "off"]; +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 _a = __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), add = _a[0], remove = _a[1]; + if (!add) { + if (isArrayLike(target)) { + return mergeMap(function(subTarget) { + return fromEvent(subTarget, eventName, options); + })(innerFrom(target)); + } + } + if (!add) { + 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]); + }; + add(handler); + return function() { + return remove(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 n = 0; + return scheduler.schedule(function() { + if (!subscriber.closed) { + subscriber.next(n++); + 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)); +} +var NEVER = new Observable(noop); +var isArray3 = Array.isArray; +function argsOrArgArray(args) { + return args.length === 1 && isArray3(args[0]) ? args[0] : args; +} +function filter(predicate, thisArg) { + return operate(function(source2, subscriber) { + var index = 0; + source2.subscribe(createOperatorSubscriber(subscriber, function(value) { + return predicate.call(thisArg, value, index++) && 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(i2) { + subscriptions.push(innerFrom(sources[i2]).subscribe(createOperatorSubscriber(subscriber, function(value) { + if (subscriptions) { + for (var s = 0; s < subscriptions.length; s++) { + s !== i2 && subscriptions[s].unsubscribe(); + } + subscriptions = null; + } + subscriber.next(value); + }))); + }; + for (var i = 0; subscriptions && !subscriber.closed && i < sources.length; i++) { + _loop_1(i); + } + }; +} +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, _a, e_2, _b; + 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 && (_a = buffers_1.return)) + _a.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 && (_b = toEmit_1.return)) + _b.call(toEmit_1); + } finally { + if (e_2) + throw e_2.error; + } + } + } + }, function() { + var e_3, _a; + 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 && (_a = buffers_2.return)) + _a.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, index) { + return innerFrom(delayDurationSelector(value, index)).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(v, i) { + return predicate(v, i, 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, index) { + return accumulator(state, value, index); + }, 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 _a = config2.count, count = _a === void 0 ? Infinity : _a, delay2 = config2.delay, _b = config2.resetOnSuccess, resetOnSuccess = _b === void 0 ? false : _b; + 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 index = 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 = index++; + 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 _a; + (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver); + var isUnsub = true; + source2.subscribe(createOperatorSubscriber(subscriber, function(value) { + var _a2; + (_a2 = tapObserver.next) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, value); + subscriber.next(value); + }, function() { + var _a2; + isUnsub = false; + (_a2 = tapObserver.complete) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver); + subscriber.complete(); + }, function(err) { + var _a2; + isUnsub = false; + (_a2 = tapObserver.error) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, err); + subscriber.error(err); + }, function() { + var _a2, _b; + if (isUnsub) { + (_a2 = tapObserver.unsubscribe) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver); + } + (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver); + })); + }) : identity; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/EventEmitter.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/third_party/mitt/mitt.js +init_cjs_shim(); +function mitt_default(n) { + return { all: n = n || /* @__PURE__ */ new Map(), on: function(t, e) { + var i = n.get(t); + i ? i.push(e) : n.set(t, [e]); + }, off: function(t, e) { + var i = n.get(t); + i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, [])); + }, emit: function(t, e) { + var i = n.get(t); + i && i.slice().map(function(n2) { + n2(e); + }), (i = n.get("*")) && i.slice().map(function(n2) { + n2(t, e); + }); + } }; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/util/disposable.js +init_cjs_shim(); +Symbol.dispose ??= Symbol("dispose"); +Symbol.asyncDispose ??= Symbol("asyncDispose"); +var disposeSymbol = Symbol.dispose; +var asyncDisposeSymbol = Symbol.asyncDispose; +var DisposableStack = class { + #disposed = false; + #stack = []; + /** + * Returns a value indicating whether this stack has been disposed. + */ + get disposed() { + return this.#disposed; + } + /** + * Disposes each resource in the stack in the reverse order that they were added. + */ + dispose() { + if (this.#disposed) { + return; + } + this.#disposed = true; + for (const resource of this.#stack.reverse()) { + resource[disposeSymbol](); + } + } + /** + * Adds a disposable resource to the stack, returning the resource. + * + * @param value - The resource to add. `null` and `undefined` will not be added, + * but will be returned. + * @returns The provided `value`. + */ + use(value) { + if (value) { + this.#stack.push(value); + } + return value; + } + /** + * Adds a value and associated disposal callback as a resource to the stack. + * + * @param value - The value to add. + * @param onDispose - The callback to use in place of a `[disposeSymbol]()` + * method. Will be invoked with `value` as the first parameter. + * @returns The provided `value`. + */ + adopt(value, onDispose) { + this.#stack.push({ + [disposeSymbol]() { + onDispose(value); + } + }); + return value; + } + /** + * Adds a callback to be invoked when the stack is disposed. + */ + defer(onDispose) { + this.#stack.push({ + [disposeSymbol]() { + onDispose(); + } + }); + } + /** + * Move all resources out of this stack and into a new `DisposableStack`, and + * marks this stack as disposed. + * + * @example + * + * ```ts + * class C { + * #res1: Disposable; + * #res2: Disposable; + * #disposables: DisposableStack; + * constructor() { + * // stack will be disposed when exiting constructor for any reason + * using stack = new DisposableStack(); + * + * // get first resource + * this.#res1 = stack.use(getResource1()); + * + * // get second resource. If this fails, both `stack` and `#res1` will be disposed. + * this.#res2 = stack.use(getResource2()); + * + * // all operations succeeded, move resources out of `stack` so that + * // they aren't disposed when constructor exits + * this.#disposables = stack.move(); + * } + * + * [disposeSymbol]() { + * this.#disposables.dispose(); + * } + * } + * ``` + */ + move() { + if (this.#disposed) { + throw new ReferenceError("a disposed stack can not use anything new"); + } + const stack = new DisposableStack(); + stack.#stack = this.#stack; + this.#disposed = true; + return stack; + } + [disposeSymbol] = this.dispose; + [Symbol.toStringTag] = "DisposableStack"; +}; +var AsyncDisposableStack = class { + #disposed = false; + #stack = []; + /** + * Returns a value indicating whether this stack has been disposed. + */ + get disposed() { + return this.#disposed; + } + /** + * Disposes each resource in the stack in the reverse order that they were added. + */ + async dispose() { + if (this.#disposed) { + return; + } + this.#disposed = true; + for (const resource of this.#stack.reverse()) { + await resource[asyncDisposeSymbol](); + } + } + /** + * Adds a disposable resource to the stack, returning the resource. + * + * @param value - The resource to add. `null` and `undefined` will not be added, + * but will be returned. + * @returns The provided `value`. + */ + use(value) { + if (value) { + this.#stack.push(value); + } + return value; + } + /** + * Adds a value and associated disposal callback as a resource to the stack. + * + * @param value - The value to add. + * @param onDispose - The callback to use in place of a `[disposeSymbol]()` + * method. Will be invoked with `value` as the first parameter. + * @returns The provided `value`. + */ + adopt(value, onDispose) { + this.#stack.push({ + [asyncDisposeSymbol]() { + return onDispose(value); + } + }); + return value; + } + /** + * Adds a callback to be invoked when the stack is disposed. + */ + defer(onDispose) { + this.#stack.push({ + [asyncDisposeSymbol]() { + return onDispose(); + } + }); + } + /** + * Move all resources out of this stack and into a new `DisposableStack`, and + * marks this stack as disposed. + * + * @example + * + * ```ts + * class C { + * #res1: Disposable; + * #res2: Disposable; + * #disposables: DisposableStack; + * constructor() { + * // stack will be disposed when exiting constructor for any reason + * using stack = new DisposableStack(); + * + * // get first resource + * this.#res1 = stack.use(getResource1()); + * + * // get second resource. If this fails, both `stack` and `#res1` will be disposed. + * this.#res2 = stack.use(getResource2()); + * + * // all operations succeeded, move resources out of `stack` so that + * // they aren't disposed when constructor exits + * this.#disposables = stack.move(); + * } + * + * [disposeSymbol]() { + * this.#disposables.dispose(); + * } + * } + * ``` + */ + move() { + if (this.#disposed) { + throw new ReferenceError("a disposed stack can not use anything new"); + } + const stack = new AsyncDisposableStack(); + stack.#stack = this.#stack; + this.#disposed = true; + return stack; + } + [asyncDisposeSymbol] = this.dispose; + [Symbol.toStringTag] = "AsyncDisposableStack"; +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/EventEmitter.js +var EventEmitter = class { + #emitter; + #handlers = /* @__PURE__ */ new Map(); + /** + * If you pass an emitter, the returned emitter will wrap the passed emitter. + * + * @internal + */ + constructor(emitter = mitt_default(/* @__PURE__ */ new Map())) { + this.#emitter = emitter; + } + /** + * Bind an event listener to fire when an event occurs. + * @param type - the event type you'd like to listen to. Can be a string or symbol. + * @param handler - the function to be called when the event occurs. + * @returns `this` to enable you to chain method calls. + */ + on(type, handler) { + const handlers = this.#handlers.get(type); + if (handlers === void 0) { + this.#handlers.set(type, [handler]); + } else { + handlers.push(handler); + } + this.#emitter.on(type, handler); + return this; + } + /** + * Remove an event listener from firing. + * @param type - the event type you'd like to stop listening to. + * @param handler - the function that should be removed. + * @returns `this` to enable you to chain method calls. + */ + off(type, handler) { + const handlers = this.#handlers.get(type) ?? []; + if (handler === void 0) { + for (const handler2 of handlers) { + this.#emitter.off(type, handler2); + } + this.#handlers.delete(type); + return this; + } + const index = handlers.lastIndexOf(handler); + if (index > -1) { + this.#emitter.off(type, ...handlers.splice(index, 1)); + } + return this; + } + /** + * Emit an event and call any associated listeners. + * + * @param type - the event you'd like to emit + * @param eventData - any data you'd like to emit with the event + * @returns `true` if there are any listeners, `false` if there are not. + */ + emit(type, event) { + this.#emitter.emit(type, event); + return this.listenerCount(type) > 0; + } + /** + * Like `on` but the listener will only be fired once and then it will be removed. + * @param type - the event you'd like to listen to + * @param handler - the handler function to run when the event occurs + * @returns `this` to enable you to chain method calls. + */ + once(type, handler) { + const onceHandler = (eventData) => { + handler(eventData); + this.off(type, onceHandler); + }; + return this.on(type, onceHandler); + } + /** + * Gets the number of listeners for a given event. + * + * @param type - the event to get the listener count for + * @returns the number of listeners bound to the given event + */ + listenerCount(type) { + return this.#handlers.get(type)?.length || 0; + } + /** + * Removes all listeners. If given an event argument, it will remove only + * listeners for that event. + * + * @param type - the event to remove listeners for. + * @returns `this` to enable you to chain method calls. + */ + removeAllListeners(type) { + if (type !== void 0) { + return this.off(type); + } + this[disposeSymbol](); + return this; + } + /** + * @internal + */ + [disposeSymbol]() { + for (const [type, handlers] of this.#handlers) { + for (const handler of handlers) { + this.#emitter.off(type, handler); + } + } + this.#handlers.clear(); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/environment.js +init_cjs_shim(); +var isNode = !!(typeof process !== "undefined" && process.version); +var environment = { + value: { + get fs() { + throw new Error("fs is not available in this environment"); + }, + get ScreenRecorder() { + throw new Error("ScreenRecorder is not available in this environment"); + } + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/util/assert.js +init_cjs_shim(); +var assert = (value, message) => { + if (!value) { + throw new Error(message); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/util/encoding.js +init_cjs_shim(); +function stringToTypedArray(string, base64Encoded = false) { + if (base64Encoded) { + const binaryString = atob(string); + return Uint8Array.from(binaryString, (m) => { + return m.codePointAt(0); + }); + } + return new TextEncoder().encode(string); +} +function stringToBase64(str) { + return typedArrayToBase64(new TextEncoder().encode(str)); +} +function typedArrayToBase64(typedArray) { + const chunkSize = 65534; + const chunks = []; + for (let i = 0; i < typedArray.length; i += chunkSize) { + const chunk = typedArray.subarray(i, i + chunkSize); + chunks.push(String.fromCodePoint.apply(null, chunk)); + } + const binaryString = chunks.join(""); + return btoa(binaryString); +} +function mergeUint8Arrays(items) { + let length = 0; + for (const item of items) { + length += item.length; + } + const result = new Uint8Array(length); + let offset = 0; + for (const item of items) { + result.set(item, offset); + offset += item.length; + } + return result; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/Debug.js +init_cjs_shim(); +var debugModule = null; +async function importDebug() { + if (!debugModule) { + debugModule = (await import("./src-X2XRWCOR.mjs")).default; + } + return debugModule; +} +var debug = (prefix) => { + if (isNode) { + return async (...logArgs) => { + if (captureLogs) { + capturedLogs.push(prefix + logArgs); + } + (await importDebug())(prefix)(logArgs); + }; + } + return (...logArgs) => { + const debugLevel = globalThis.__PUPPETEER_DEBUG; + if (!debugLevel) { + return; + } + const everythingShouldBeLogged = debugLevel === "*"; + const prefixMatchesDebugLevel = everythingShouldBeLogged || /** + * If the debug level is `foo*`, that means we match any prefix that + * starts with `foo`. If the level is `foo`, we match only the prefix + * `foo`. + */ + (debugLevel.endsWith("*") ? prefix.startsWith(debugLevel) : prefix === debugLevel); + if (!prefixMatchesDebugLevel) { + return; + } + console.log(`${prefix}:`, ...logArgs); + }; +}; +var capturedLogs = []; +var captureLogs = false; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/Errors.js +init_cjs_shim(); +var PuppeteerError = class extends Error { + /** + * @internal + */ + constructor(message, options) { + super(message, options); + this.name = this.constructor.name; + } + /** + * @internal + */ + get [Symbol.toStringTag]() { + return this.constructor.name; + } +}; +var TimeoutError = class extends PuppeteerError { +}; +var TouchError = class extends PuppeteerError { +}; +var ProtocolError = class extends PuppeteerError { + #code; + #originalMessage = ""; + set code(code) { + this.#code = code; + } + /** + * @readonly + * @public + */ + get code() { + return this.#code; + } + set originalMessage(originalMessage) { + this.#originalMessage = originalMessage; + } + /** + * @readonly + * @public + */ + get originalMessage() { + return this.#originalMessage; + } +}; +var UnsupportedOperation = class extends PuppeteerError { +}; +var TargetCloseError = class extends ProtocolError { +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/util.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/PDFOptions.js +init_cjs_shim(); +var paperFormats = { + letter: { width: 8.5, height: 11 }, + legal: { width: 8.5, height: 14 }, + tabloid: { width: 11, height: 17 }, + ledger: { width: 17, height: 11 }, + a0: { width: 33.1102, height: 46.811 }, + a1: { width: 23.3858, height: 33.1102 }, + a2: { width: 16.5354, height: 23.3858 }, + a3: { width: 11.6929, height: 16.5354 }, + a4: { width: 8.2677, height: 11.6929 }, + a5: { width: 5.8268, height: 8.2677 }, + a6: { width: 4.1339, height: 5.8268 } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/util.js +var debugError = debug("puppeteer:error"); +var DEFAULT_VIEWPORT = Object.freeze({ width: 800, height: 600 }); +var SOURCE_URL = Symbol("Source URL for Puppeteer evaluation scripts"); +var _functionName, _siteString; +var _PuppeteerURL = class { + constructor() { + __privateAdd(this, _functionName, void 0); + __privateAdd(this, _siteString, void 0); + } + static fromCallSite(functionName, site) { + const url = new _PuppeteerURL(); + __privateSet(url, _functionName, functionName); + __privateSet(url, _siteString, site.toString()); + return url; + } + get functionName() { + return __privateGet(this, _functionName); + } + get siteString() { + return __privateGet(this, _siteString); + } + toString() { + return `pptr:${[ + __privateGet(this, _functionName), + encodeURIComponent(__privateGet(this, _siteString)) + ].join(";")}`; + } +}; +var PuppeteerURL = _PuppeteerURL; +_functionName = new WeakMap(); +_siteString = new WeakMap(); +__publicField(PuppeteerURL, "INTERNAL_URL", "pptr:internal"); +__publicField(PuppeteerURL, "parse", (url) => { + url = url.slice("pptr:".length); + const [functionName = "", siteString = ""] = url.split(";"); + const puppeteerUrl = new _PuppeteerURL(); + __privateSet(puppeteerUrl, _functionName, functionName); + __privateSet(puppeteerUrl, _siteString, decodeURIComponent(siteString)); + return puppeteerUrl; +}); +__publicField(PuppeteerURL, "isPuppeteerURL", (url) => { + return url.startsWith("pptr:"); +}); +var withSourcePuppeteerURLIfNone = (functionName, object) => { + if (Object.prototype.hasOwnProperty.call(object, SOURCE_URL)) { + return object; + } + const original = Error.prepareStackTrace; + Error.prepareStackTrace = (_, stack) => { + return stack[2]; + }; + const site = new Error().stack; + Error.prepareStackTrace = original; + return Object.assign(object, { + [SOURCE_URL]: PuppeteerURL.fromCallSite(functionName, site) + }); +}; +var getSourcePuppeteerURLIfAvailable = (object) => { + if (Object.prototype.hasOwnProperty.call(object, SOURCE_URL)) { + return object[SOURCE_URL]; + } + return void 0; +}; +var isString = (obj) => { + return typeof obj === "string" || obj instanceof String; +}; +var isNumber = (obj) => { + return typeof obj === "number" || obj instanceof Number; +}; +var isPlainObject = (obj) => { + return typeof obj === "object" && obj?.constructor === Object; +}; +var isRegExp = (obj) => { + return typeof obj === "object" && obj?.constructor === RegExp; +}; +var isDate = (obj) => { + return typeof obj === "object" && obj?.constructor === Date; +}; +function evaluationString(fun, ...args) { + if (isString(fun)) { + assert(args.length === 0, "Cannot evaluate a string with arguments"); + return fun; + } + function serializeArgument(arg) { + if (Object.is(arg, void 0)) { + return "undefined"; + } + return JSON.stringify(arg); + } + return `(${fun})(${args.map(serializeArgument).join(",")})`; +} +async function getReadableAsTypedArray(readable, path) { + const buffers = []; + const reader = readable.getReader(); + if (path) { + const fileHandle = await environment.value.fs.promises.open(path, "w+"); + try { + while (true) { + const { done, value } = await reader.read(); + if (done) { + break; + } + buffers.push(value); + await fileHandle.writeFile(value); + } + } finally { + await fileHandle.close(); + } + } else { + while (true) { + const { done, value } = await reader.read(); + if (done) { + break; + } + buffers.push(value); + } + } + try { + const concat2 = mergeUint8Arrays(buffers); + if (concat2.length === 0) { + return null; + } + return concat2; + } catch (error) { + debugError(error); + return null; + } +} +async function getReadableFromProtocolStream(client, handle) { + return new ReadableStream({ + async pull(controller) { + function getUnit8Array(data2, isBase64) { + if (isBase64) { + return Uint8Array.from(atob(data2), (m) => { + return m.codePointAt(0); + }); + } + const encoder = new TextEncoder(); + return encoder.encode(data2); + } + const { data, base64Encoded, eof } = await client.send("IO.read", { + handle + }); + controller.enqueue(getUnit8Array(data, base64Encoded ?? false)); + if (eof) { + await client.send("IO.close", { handle }); + controller.close(); + } + } + }); +} +function validateDialogType(type) { + let dialogType = null; + const validDialogTypes = /* @__PURE__ */ new Set([ + "alert", + "confirm", + "prompt", + "beforeunload" + ]); + if (validDialogTypes.has(type)) { + dialogType = type; + } + assert(dialogType, `Unknown javascript dialog type: ${type}`); + return dialogType; +} +function timeout(ms, cause) { + return ms === 0 ? NEVER : timer(ms).pipe(map(() => { + throw new TimeoutError(`Timed out after waiting ${ms}ms`, { cause }); + })); +} +var UTILITY_WORLD_NAME = "__puppeteer_utility_world__" + packageVersion; +var SOURCE_URL_REGEX = /^[\x20\t]*\/\/[@#] sourceURL=\s{0,10}(\S*?)\s{0,10}$/m; +function getSourceUrlComment(url) { + return `//# sourceURL=${url}`; +} +var NETWORK_IDLE_TIME = 500; +function parsePDFOptions(options = {}, lengthUnit = "in") { + const defaults = { + scale: 1, + displayHeaderFooter: false, + headerTemplate: "", + footerTemplate: "", + printBackground: false, + landscape: false, + pageRanges: "", + preferCSSPageSize: false, + omitBackground: false, + outline: false, + tagged: true, + waitForFonts: true + }; + let width = 8.5; + let height = 11; + if (options.format) { + const format = paperFormats[options.format.toLowerCase()]; + assert(format, "Unknown paper format: " + options.format); + width = format.width; + height = format.height; + } else { + width = convertPrintParameterToInches(options.width, lengthUnit) ?? width; + height = convertPrintParameterToInches(options.height, lengthUnit) ?? height; + } + const margin = { + top: convertPrintParameterToInches(options.margin?.top, lengthUnit) || 0, + left: convertPrintParameterToInches(options.margin?.left, lengthUnit) || 0, + bottom: convertPrintParameterToInches(options.margin?.bottom, lengthUnit) || 0, + right: convertPrintParameterToInches(options.margin?.right, lengthUnit) || 0 + }; + if (options.outline) { + options.tagged = true; + } + return { + ...defaults, + ...options, + width, + height, + margin + }; +} +var unitToPixels = { + px: 1, + in: 96, + cm: 37.8, + mm: 3.78 +}; +function convertPrintParameterToInches(parameter, lengthUnit = "in") { + if (typeof parameter === "undefined") { + return void 0; + } + let pixels; + if (isNumber(parameter)) { + pixels = parameter; + } else if (isString(parameter)) { + const text = parameter; + let unit = text.substring(text.length - 2).toLowerCase(); + let valueText = ""; + if (unit in unitToPixels) { + valueText = text.substring(0, text.length - 2); + } else { + unit = "px"; + valueText = text; + } + const value = Number(valueText); + assert(!isNaN(value), "Failed to parse parameter value: " + text); + pixels = value * unitToPixels[unit]; + } else { + throw new Error("page.pdf() Cannot handle parameter type: " + typeof parameter); + } + return pixels / unitToPixels[lengthUnit]; +} +function fromEmitterEvent(emitter, eventName) { + return new Observable((subscriber) => { + const listener = (event) => { + subscriber.next(event); + }; + emitter.on(eventName, listener); + return () => { + emitter.off(eventName, listener); + }; + }); +} +function fromAbortSignal(signal, cause) { + return signal ? fromEvent(signal, "abort").pipe(map(() => { + if (signal.reason instanceof Error) { + signal.reason.cause = cause; + throw signal.reason; + } + throw new Error(signal.reason, { cause }); + })) : NEVER; +} +function filterAsync(predicate) { + return mergeMap((value) => { + return from(Promise.resolve(predicate(value))).pipe(filter((isMatch) => { + return isMatch; + }), map(() => { + return value; + })); + }); +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/api/Browser.js +init_cjs_shim(); +var WEB_PERMISSION_TO_PROTOCOL_PERMISSION = /* @__PURE__ */ new Map([ + ["geolocation", "geolocation"], + ["midi", "midi"], + ["notifications", "notifications"], + // TODO: push isn't a valid type? + // ['push', 'push'], + ["camera", "videoCapture"], + ["microphone", "audioCapture"], + ["background-sync", "backgroundSync"], + ["ambient-light-sensor", "sensors"], + ["accelerometer", "sensors"], + ["gyroscope", "sensors"], + ["magnetometer", "sensors"], + ["accessibility-events", "accessibilityEvents"], + ["clipboard-read", "clipboardReadWrite"], + ["clipboard-write", "clipboardReadWrite"], + ["clipboard-sanitized-write", "clipboardSanitizedWrite"], + ["payment-handler", "paymentHandler"], + ["persistent-storage", "durableStorage"], + ["idle-detection", "idleDetection"], + // chrome-specific permissions we have. + ["midi-sysex", "midiSysex"] +]); +var Browser = class extends EventEmitter { + /** + * @internal + */ + constructor() { + super(); + } + /** + * Waits until a {@link Target | target} matching the given `predicate` + * appears and returns it. + * + * This will look all open {@link BrowserContext | browser contexts}. + * + * @example Finding a target for a page opened via `window.open`: + * + * ```ts + * await page.evaluate(() => window.open('https://www.example.com/')); + * const newWindowTarget = await browser.waitForTarget( + * target => target.url() === 'https://www.example.com/', + * ); + * ``` + */ + async waitForTarget(predicate, options = {}) { + const { timeout: ms = 3e4, signal } = options; + return await firstValueFrom(merge(fromEmitterEvent( + this, + "targetcreated" + /* BrowserEvent.TargetCreated */ + ), fromEmitterEvent( + this, + "targetchanged" + /* BrowserEvent.TargetChanged */ + ), from(this.targets())).pipe(filterAsync(predicate), raceWith(fromAbortSignal(signal), timeout(ms)))); + } + /** + * Gets a list of all open {@link Page | pages} inside this {@link Browser}. + * + * If there are multiple {@link BrowserContext | browser contexts}, this + * returns all {@link Page | pages} in all + * {@link BrowserContext | browser contexts}. + * + * @remarks Non-visible {@link Page | pages}, such as `"background_page"`, + * will not be listed here. You can find them using {@link Target.page}. + */ + async pages() { + const contextPages = await Promise.all(this.browserContexts().map((context2) => { + return context2.pages(); + })); + return contextPages.reduce((acc, x) => { + return acc.concat(x); + }, []); + } + /** + * Whether Puppeteer is connected to this {@link Browser | browser}. + * + * @deprecated Use {@link Browser | Browser.connected}. + */ + isConnected() { + return this.connected; + } + /** @internal */ + [disposeSymbol]() { + if (this.process()) { + return void this.close().catch(debugError); + } + return void this.disconnect().catch(debugError); + } + /** @internal */ + [asyncDisposeSymbol]() { + if (this.process()) { + return this.close(); + } + return this.disconnect(); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/api/BrowserContext.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/util/Mutex.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/util/Deferred.js +init_cjs_shim(); +var Deferred = class { + static create(opts) { + return new Deferred(opts); + } + static async race(awaitables) { + const deferredWithTimeout = /* @__PURE__ */ new Set(); + try { + const promises = awaitables.map((value) => { + if (value instanceof Deferred) { + if (value.#timeoutId) { + deferredWithTimeout.add(value); + } + return value.valueOrThrow(); + } + return value; + }); + return await Promise.race(promises); + } finally { + for (const deferred of deferredWithTimeout) { + deferred.reject(new Error("Timeout cleared")); + } + } + } + #isResolved = false; + #isRejected = false; + #value; + // SAFETY: This is ensured by #taskPromise. + #resolve; + // TODO: Switch to Promise.withResolvers with Node 22 + #taskPromise = new Promise((resolve) => { + this.#resolve = resolve; + }); + #timeoutId; + #timeoutError; + constructor(opts) { + if (opts && opts.timeout > 0) { + this.#timeoutError = new TimeoutError(opts.message); + this.#timeoutId = setTimeout(() => { + this.reject(this.#timeoutError); + }, opts.timeout); + } + } + #finish(value) { + clearTimeout(this.#timeoutId); + this.#value = value; + this.#resolve(); + } + resolve(value) { + if (this.#isRejected || this.#isResolved) { + return; + } + this.#isResolved = true; + this.#finish(value); + } + reject(error) { + if (this.#isRejected || this.#isResolved) { + return; + } + this.#isRejected = true; + this.#finish(error); + } + resolved() { + return this.#isResolved; + } + finished() { + return this.#isResolved || this.#isRejected; + } + value() { + return this.#value; + } + #promise; + valueOrThrow() { + if (!this.#promise) { + this.#promise = (async () => { + await this.#taskPromise; + if (this.#isRejected) { + throw this.#value; + } + return this.#value; + })(); + } + return this.#promise; + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/util/Mutex.js +var _locked, _acquirers; +var _Mutex = class { + constructor() { + __privateAdd(this, _locked, false); + __privateAdd(this, _acquirers, []); + } + // This is FIFO. + async acquire(onRelease) { + if (!__privateGet(this, _locked)) { + __privateSet(this, _locked, true); + return new _Mutex.Guard(this); + } + const deferred = Deferred.create(); + __privateGet(this, _acquirers).push(deferred.resolve.bind(deferred)); + await deferred.valueOrThrow(); + return new _Mutex.Guard(this, onRelease); + } + release() { + const resolve = __privateGet(this, _acquirers).shift(); + if (!resolve) { + __privateSet(this, _locked, false); + return; + } + resolve(); + } +}; +var Mutex = _Mutex; +_locked = new WeakMap(); +_acquirers = new WeakMap(); +__publicField(Mutex, "Guard", class Guard { + #mutex; + #onRelease; + constructor(mutex, onRelease) { + this.#mutex = mutex; + this.#onRelease = onRelease; + } + [disposeSymbol]() { + this.#onRelease?.(); + return this.#mutex.release(); + } +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/api/BrowserContext.js +var BrowserContext = class extends EventEmitter { + /** + * @internal + */ + constructor() { + super(); + } + /** + * If defined, indicates an ongoing screenshot opereation. + */ + #pageScreenshotMutex; + #screenshotOperationsCount = 0; + /** + * @internal + */ + startScreenshot() { + const mutex = this.#pageScreenshotMutex || new Mutex(); + this.#pageScreenshotMutex = mutex; + this.#screenshotOperationsCount++; + return mutex.acquire(() => { + this.#screenshotOperationsCount--; + if (this.#screenshotOperationsCount === 0) { + this.#pageScreenshotMutex = void 0; + } + }); + } + /** + * @internal + */ + waitForScreenshotOperations() { + return this.#pageScreenshotMutex?.acquire(); + } + /** + * Waits until a {@link Target | target} matching the given `predicate` + * appears and returns it. + * + * This will look all open {@link BrowserContext | browser contexts}. + * + * @example Finding a target for a page opened via `window.open`: + * + * ```ts + * await page.evaluate(() => window.open('https://www.example.com/')); + * const newWindowTarget = await browserContext.waitForTarget( + * target => target.url() === 'https://www.example.com/', + * ); + * ``` + */ + async waitForTarget(predicate, options = {}) { + const { timeout: ms = 3e4 } = options; + return await firstValueFrom(merge(fromEmitterEvent( + this, + "targetcreated" + /* BrowserContextEvent.TargetCreated */ + ), fromEmitterEvent( + this, + "targetchanged" + /* BrowserContextEvent.TargetChanged */ + ), from(this.targets())).pipe(filterAsync(predicate), raceWith(timeout(ms)))); + } + /** + * Whether this {@link BrowserContext | browser context} is closed. + */ + get closed() { + return !this.browser().browserContexts().includes(this); + } + /** + * Identifier for this {@link BrowserContext | browser context}. + */ + get id() { + return void 0; + } + /** @internal */ + [disposeSymbol]() { + return void this.close().catch(debugError); + } + /** @internal */ + [asyncDisposeSymbol]() { + return this.close(); + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/util/ErrorLike.js +init_cjs_shim(); +function isErrorLike(obj) { + return typeof obj === "object" && obj !== null && "name" in obj && "message" in obj; +} +function rewriteError(error, message, originalMessage) { + error.message = message; + error.originalMessage = originalMessage ?? error.originalMessage; + return error; +} +function createProtocolErrorMessage(object) { + let message = object.error.message; + if (object.error && typeof object.error === "object" && "data" in object.error) { + message += ` ${object.error.data}`; + } + return message; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/util/Function.js +init_cjs_shim(); +var createdFunctions = /* @__PURE__ */ new Map(); +var createFunction = (functionValue) => { + let fn = createdFunctions.get(functionValue); + if (fn) { + return fn; + } + fn = new Function(`return ${functionValue}`)(); + createdFunctions.set(functionValue, fn); + return fn; +}; +function stringifyFunction(fn) { + let value = fn.toString(); + try { + new Function(`(${value})`); + } catch (err) { + if (err.message.includes(`Refused to evaluate a string as JavaScript because 'unsafe-eval' is not an allowed source of script in the following Content Security Policy directive`)) { + return value; + } + let prefix = "function "; + if (value.startsWith("async ")) { + prefix = `async ${prefix}`; + value = value.substring("async ".length); + } + value = `${prefix}${value}`; + try { + new Function(`(${value})`); + } catch { + throw new Error("Passed function cannot be serialized!"); + } + } + return value; +} +var interpolateFunction = (fn, replacements) => { + let value = stringifyFunction(fn); + for (const [name, jsValue] of Object.entries(replacements)) { + value = value.replace( + new RegExp(`PLACEHOLDER\\(\\s*(?:'${name}'|"${name}")\\s*\\)`, "g"), + // Wrapping this ensures tersers that accidentally inline PLACEHOLDER calls + // are still valid. Without, we may get calls like ()=>{...}() which is + // not valid. + `(${jsValue})` + ); + } + return createFunction(value); +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/LazyArg.js +init_cjs_shim(); +var _get; +var _LazyArg = class { + constructor(get) { + __privateAdd(this, _get, void 0); + __privateSet(this, _get, get); + } + async get(context2) { + return await __privateGet(this, _get).call(this, context2); + } +}; +var LazyArg = _LazyArg; +_get = new WeakMap(); +__publicField(LazyArg, "create", (get) => { + return new _LazyArg(get); +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/util/AsyncIterableUtil.js +init_cjs_shim(); +var AsyncIterableUtil = class { + static async *map(iterable, map2) { + for await (const value of iterable) { + yield await map2(value); + } + } + static async *flatMap(iterable, map2) { + for await (const value of iterable) { + yield* map2(value); + } + } + static async collect(iterable) { + const result = []; + for await (const value of iterable) { + result.push(value); + } + return result; + } + static async first(iterable) { + for await (const value of iterable) { + return value; + } + return; + } +}; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/AriaQueryHandler.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/QueryHandler.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/api/ElementHandleSymbol.js +init_cjs_shim(); +var _isElementHandle = Symbol("_isElementHandle"); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/HandleIterator.js +init_cjs_shim(); +var __addDisposableResource = function(env, value, async2) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async2) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async2) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env.stack.push({ value, dispose, async: async2 }); + } else if (async2) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources = function(SuppressedError2) { + return function(env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) + throw env.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var DEFAULT_BATCH_SIZE = 20; +async function* fastTransposeIteratorHandle(iterator2, size) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const array = __addDisposableResource(env_1, await iterator2.evaluateHandle(async (iterator3, size2) => { + const results = []; + while (results.length < size2) { + const result = await iterator3.next(); + if (result.done) { + break; + } + results.push(result.value); + } + return results; + }, size), false); + const properties = await array.getProperties(); + const handles = properties.values(); + const stack = __addDisposableResource(env_1, new DisposableStack(), false); + stack.defer(() => { + for (const handle_1 of handles) { + const env_2 = { stack: [], error: void 0, hasError: false }; + try { + const handle = __addDisposableResource(env_2, handle_1, false); + handle[disposeSymbol](); + } catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } finally { + __disposeResources(env_2); + } + } + }); + yield* handles; + return properties.size === 0; + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources(env_1); + } +} +async function* transposeIteratorHandle(iterator2) { + let size = DEFAULT_BATCH_SIZE; + while (!(yield* fastTransposeIteratorHandle(iterator2, size))) { + size <<= 1; + } +} +async function* transposeIterableHandle(handle) { + const env_3 = { stack: [], error: void 0, hasError: false }; + try { + const generatorHandle = __addDisposableResource(env_3, await handle.evaluateHandle((iterable) => { + return async function* () { + yield* iterable; + }(); + }), false); + yield* transposeIteratorHandle(generatorHandle); + } catch (e_3) { + env_3.error = e_3; + env_3.hasError = true; + } finally { + __disposeResources(env_3); + } +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/QueryHandler.js +var __addDisposableResource2 = function(env, value, async2) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async2) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async2) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env.stack.push({ value, dispose, async: async2 }); + } else if (async2) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources2 = function(SuppressedError2) { + return function(env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) + throw env.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var QueryHandler = class { + static get _querySelector() { + if (this.querySelector) { + return this.querySelector; + } + if (!this.querySelectorAll) { + throw new Error("Cannot create default `querySelector`."); + } + return this.querySelector = interpolateFunction(async (node, selector, PuppeteerUtil) => { + const querySelectorAll = PLACEHOLDER("querySelectorAll"); + const results = querySelectorAll(node, selector, PuppeteerUtil); + for await (const result of results) { + return result; + } + return null; + }, { + querySelectorAll: stringifyFunction(this.querySelectorAll) + }); + } + static get _querySelectorAll() { + if (this.querySelectorAll) { + return this.querySelectorAll; + } + if (!this.querySelector) { + throw new Error("Cannot create default `querySelectorAll`."); + } + return this.querySelectorAll = interpolateFunction(async function* (node, selector, PuppeteerUtil) { + const querySelector = PLACEHOLDER("querySelector"); + const result = await querySelector(node, selector, PuppeteerUtil); + if (result) { + yield result; + } + }, { + querySelector: stringifyFunction(this.querySelector) + }); + } + /** + * Queries for multiple nodes given a selector and {@link ElementHandle}. + * + * Akin to {@link https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll | Document.querySelectorAll()}. + */ + static async *queryAll(element, selector) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const handle = __addDisposableResource2(env_1, await element.evaluateHandle(this._querySelectorAll, selector, LazyArg.create((context2) => { + return context2.puppeteerUtil; + })), false); + yield* transposeIterableHandle(handle); + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources2(env_1); + } + } + /** + * Queries for a single node given a selector and {@link ElementHandle}. + * + * Akin to {@link https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelector}. + */ + static async queryOne(element, selector) { + const env_2 = { stack: [], error: void 0, hasError: false }; + try { + const result = __addDisposableResource2(env_2, await element.evaluateHandle(this._querySelector, selector, LazyArg.create((context2) => { + return context2.puppeteerUtil; + })), false); + if (!(_isElementHandle in result)) { + return null; + } + return result.move(); + } catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } finally { + __disposeResources2(env_2); + } + } + /** + * Waits until a single node appears for a given selector and + * {@link ElementHandle}. + * + * This will always query the handle in the Puppeteer world and migrate the + * result to the main world. + */ + static async waitFor(elementOrFrame, selector, options) { + const env_3 = { stack: [], error: void 0, hasError: false }; + try { + let frame; + const element = __addDisposableResource2(env_3, await (async () => { + if (!(_isElementHandle in elementOrFrame)) { + frame = elementOrFrame; + return; + } + frame = elementOrFrame.frame; + return await frame.isolatedRealm().adoptHandle(elementOrFrame); + })(), false); + const { visible = false, hidden = false, timeout: timeout2, signal } = options; + const polling = visible || hidden ? "raf" : options.polling; + try { + const env_4 = { stack: [], error: void 0, hasError: false }; + try { + signal?.throwIfAborted(); + const handle = __addDisposableResource2(env_4, await frame.isolatedRealm().waitForFunction(async (PuppeteerUtil, query, selector2, root, visible2) => { + const querySelector = PuppeteerUtil.createFunction(query); + const node = await querySelector(root ?? document, selector2, PuppeteerUtil); + return PuppeteerUtil.checkVisibility(node, visible2); + }, { + polling, + root: element, + timeout: timeout2, + signal + }, LazyArg.create((context2) => { + return context2.puppeteerUtil; + }), stringifyFunction(this._querySelector), selector, element, visible ? true : hidden ? false : void 0), false); + if (signal?.aborted) { + throw signal.reason; + } + if (!(_isElementHandle in handle)) { + return null; + } + return await frame.mainRealm().transferHandle(handle); + } catch (e_3) { + env_4.error = e_3; + env_4.hasError = true; + } finally { + __disposeResources2(env_4); + } + } catch (error) { + if (!isErrorLike(error)) { + throw error; + } + if (error.name === "AbortError") { + throw error; + } + error.message = `Waiting for selector \`${selector}\` failed: ${error.message}`; + throw error; + } + } catch (e_4) { + env_3.error = e_4; + env_3.hasError = true; + } finally { + __disposeResources2(env_3); + } + } +}; +// Either one of these may be implemented, but at least one must be. +__publicField(QueryHandler, "querySelectorAll"); +__publicField(QueryHandler, "querySelector"); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/AriaQueryHandler.js +var isKnownAttribute = (attribute) => { + return ["name", "role"].includes(attribute); +}; +var ATTRIBUTE_REGEXP = /\[\s*(?\w+)\s*=\s*(?"|')(?\\.|.*?(?=\k))\k\s*\]/g; +var parseARIASelector = (selector) => { + if (selector.length > 1e4) { + throw new Error(`Selector ${selector} is too long`); + } + const queryOptions = {}; + const defaultName = selector.replace(ATTRIBUTE_REGEXP, (_, attribute, __, value) => { + assert(isKnownAttribute(attribute), `Unknown aria attribute "${attribute}" in selector`); + queryOptions[attribute] = value; + return ""; + }); + if (defaultName && !queryOptions.name) { + queryOptions.name = defaultName; + } + return queryOptions; +}; +var _ARIAQueryHandler = class extends QueryHandler { + static async *queryAll(element, selector) { + const { name, role } = parseARIASelector(selector); + yield* element.queryAXTree(name, role); + } +}; +var ARIAQueryHandler = _ARIAQueryHandler; +__publicField(ARIAQueryHandler, "querySelector", async (node, selector, { ariaQuerySelector }) => { + return await ariaQuerySelector(node, selector); +}); +__publicField(ARIAQueryHandler, "queryOne", async (element, selector) => { + return await AsyncIterableUtil.first(_ARIAQueryHandler.queryAll(element, selector)) ?? null; +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/ScriptInjector.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/generated/injected.js +init_cjs_shim(); +var source = '"use strict";var g=Object.defineProperty;var X=Object.getOwnPropertyDescriptor;var B=Object.getOwnPropertyNames;var Y=Object.prototype.hasOwnProperty;var l=(t,e)=>{for(var r in e)g(t,r,{get:e[r],enumerable:!0})},J=(t,e,r,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of B(e))!Y.call(t,n)&&n!==r&&g(t,n,{get:()=>e[n],enumerable:!(o=X(e,n))||o.enumerable});return t};var z=t=>J(g({},"__esModule",{value:!0}),t);var pe={};l(pe,{default:()=>he});module.exports=z(pe);var N=class extends Error{constructor(e,r){super(e,r),this.name=this.constructor.name}get[Symbol.toStringTag](){return this.constructor.name}},p=class extends N{};var c=class t{static create(e){return new t(e)}static async race(e){let r=new Set;try{let o=e.map(n=>n instanceof t?(n.#n&&r.add(n),n.valueOrThrow()):n);return await Promise.race(o)}finally{for(let o of r)o.reject(new Error("Timeout cleared"))}}#e=!1;#r=!1;#o;#t;#a=new Promise(e=>{this.#t=e});#n;#i;constructor(e){e&&e.timeout>0&&(this.#i=new p(e.message),this.#n=setTimeout(()=>{this.reject(this.#i)},e.timeout))}#l(e){clearTimeout(this.#n),this.#o=e,this.#t()}resolve(e){this.#r||this.#e||(this.#e=!0,this.#l(e))}reject(e){this.#r||this.#e||(this.#r=!0,this.#l(e))}resolved(){return this.#e}finished(){return this.#e||this.#r}value(){return this.#o}#s;valueOrThrow(){return this.#s||(this.#s=(async()=>{if(await this.#a,this.#r)throw this.#o;return this.#o})()),this.#s}};var L=new Map,F=t=>{let e=L.get(t);return e||(e=new Function(`return ${t}`)(),L.set(t,e),e)};var x={};l(x,{ariaQuerySelector:()=>G,ariaQuerySelectorAll:()=>b});var G=(t,e)=>globalThis.__ariaQuerySelector(t,e),b=async function*(t,e){yield*await globalThis.__ariaQuerySelectorAll(t,e)};var E={};l(E,{cssQuerySelector:()=>K,cssQuerySelectorAll:()=>Z});var K=(t,e)=>t.querySelector(e),Z=function(t,e){return t.querySelectorAll(e)};var A={};l(A,{customQuerySelectors:()=>P});var v=class{#e=new Map;register(e,r){if(!r.queryOne&&r.queryAll){let o=r.queryAll;r.queryOne=(n,i)=>{for(let s of o(n,i))return s;return null}}else if(r.queryOne&&!r.queryAll){let o=r.queryOne;r.queryAll=(n,i)=>{let s=o(n,i);return s?[s]:[]}}else if(!r.queryOne||!r.queryAll)throw new Error("At least one query method must be defined.");this.#e.set(e,{querySelector:r.queryOne,querySelectorAll:r.queryAll})}unregister(e){this.#e.delete(e)}get(e){return this.#e.get(e)}clear(){this.#e.clear()}},P=new v;var R={};l(R,{pierceQuerySelector:()=>ee,pierceQuerySelectorAll:()=>te});var ee=(t,e)=>{let r=null,o=n=>{let i=document.createTreeWalker(n,NodeFilter.SHOW_ELEMENT);do{let s=i.currentNode;s.shadowRoot&&o(s.shadowRoot),!(s instanceof ShadowRoot)&&s!==n&&!r&&s.matches(e)&&(r=s)}while(!r&&i.nextNode())};return t instanceof Document&&(t=t.documentElement),o(t),r},te=(t,e)=>{let r=[],o=n=>{let i=document.createTreeWalker(n,NodeFilter.SHOW_ELEMENT);do{let s=i.currentNode;s.shadowRoot&&o(s.shadowRoot),!(s instanceof ShadowRoot)&&s!==n&&s.matches(e)&&r.push(s)}while(i.nextNode())};return t instanceof Document&&(t=t.documentElement),o(t),r};var u=(t,e)=>{if(!t)throw new Error(e)};var y=class{#e;#r;#o;#t;constructor(e,r){this.#e=e,this.#r=r}async start(){let e=this.#t=c.create(),r=await this.#e();if(r){e.resolve(r);return}this.#o=new MutationObserver(async()=>{let o=await this.#e();o&&(e.resolve(o),await this.stop())}),this.#o.observe(this.#r,{childList:!0,subtree:!0,attributes:!0})}async stop(){u(this.#t,"Polling never started."),this.#t.finished()||this.#t.reject(new Error("Polling stopped")),this.#o&&(this.#o.disconnect(),this.#o=void 0)}result(){return u(this.#t,"Polling never started."),this.#t.valueOrThrow()}},w=class{#e;#r;constructor(e){this.#e=e}async start(){let e=this.#r=c.create(),r=await this.#e();if(r){e.resolve(r);return}let o=async()=>{if(e.finished())return;let n=await this.#e();if(!n){window.requestAnimationFrame(o);return}e.resolve(n),await this.stop()};window.requestAnimationFrame(o)}async stop(){u(this.#r,"Polling never started."),this.#r.finished()||this.#r.reject(new Error("Polling stopped"))}result(){return u(this.#r,"Polling never started."),this.#r.valueOrThrow()}},S=class{#e;#r;#o;#t;constructor(e,r){this.#e=e,this.#r=r}async start(){let e=this.#t=c.create(),r=await this.#e();if(r){e.resolve(r);return}this.#o=setInterval(async()=>{let o=await this.#e();o&&(e.resolve(o),await this.stop())},this.#r)}async stop(){u(this.#t,"Polling never started."),this.#t.finished()||this.#t.reject(new Error("Polling stopped")),this.#o&&(clearInterval(this.#o),this.#o=void 0)}result(){return u(this.#t,"Polling never started."),this.#t.valueOrThrow()}};var _={};l(_,{PCombinator:()=>H,pQuerySelector:()=>fe,pQuerySelectorAll:()=>$});var a=class{static async*map(e,r){for await(let o of e)yield await r(o)}static async*flatMap(e,r){for await(let o of e)yield*r(o)}static async collect(e){let r=[];for await(let o of e)r.push(o);return r}static async first(e){for await(let r of e)return r}};var C={};l(C,{textQuerySelectorAll:()=>m});var re=new Set(["checkbox","image","radio"]),oe=t=>t instanceof HTMLSelectElement||t instanceof HTMLTextAreaElement||t instanceof HTMLInputElement&&!re.has(t.type),ne=new Set(["SCRIPT","STYLE"]),f=t=>!ne.has(t.nodeName)&&!document.head?.contains(t),I=new WeakMap,j=t=>{for(;t;)I.delete(t),t instanceof ShadowRoot?t=t.host:t=t.parentNode},W=new WeakSet,se=new MutationObserver(t=>{for(let e of t)j(e.target)}),d=t=>{let e=I.get(t);if(e||(e={full:"",immediate:[]},!f(t)))return e;let r="";if(oe(t))e.full=t.value,e.immediate.push(t.value),t.addEventListener("input",o=>{j(o.target)},{once:!0,capture:!0});else{for(let o=t.firstChild;o;o=o.nextSibling){if(o.nodeType===Node.TEXT_NODE){e.full+=o.nodeValue??"",r+=o.nodeValue??"";continue}r&&e.immediate.push(r),r="",o.nodeType===Node.ELEMENT_NODE&&(e.full+=d(o).full)}r&&e.immediate.push(r),t instanceof Element&&t.shadowRoot&&(e.full+=d(t.shadowRoot).full),W.has(t)||(se.observe(t,{childList:!0,characterData:!0,subtree:!0}),W.add(t))}return I.set(t,e),e};var m=function*(t,e){let r=!1;for(let o of t.childNodes)if(o instanceof Element&&f(o)){let n;o.shadowRoot?n=m(o.shadowRoot,e):n=m(o,e);for(let i of n)yield i,r=!0}r||t instanceof Element&&f(t)&&d(t).full.includes(e)&&(yield t)};var k={};l(k,{checkVisibility:()=>le,pierce:()=>T,pierceAll:()=>O});var ie=["hidden","collapse"],le=(t,e)=>{if(!t)return e===!1;if(e===void 0)return t;let r=t.nodeType===Node.TEXT_NODE?t.parentElement:t,o=window.getComputedStyle(r),n=o&&!ie.includes(o.visibility)&&!ae(r);return e===n?t:!1};function ae(t){let e=t.getBoundingClientRect();return e.width===0||e.height===0}var ce=t=>"shadowRoot"in t&&t.shadowRoot instanceof ShadowRoot;function*T(t){ce(t)?yield t.shadowRoot:yield t}function*O(t){t=T(t).next().value,yield t;let e=[document.createTreeWalker(t,NodeFilter.SHOW_ELEMENT)];for(let r of e){let o;for(;o=r.nextNode();)o.shadowRoot&&(yield o.shadowRoot,e.push(document.createTreeWalker(o.shadowRoot,NodeFilter.SHOW_ELEMENT)))}}var Q={};l(Q,{xpathQuerySelectorAll:()=>q});var q=function*(t,e,r=-1){let n=(t.ownerDocument||document).evaluate(e,t,null,XPathResult.ORDERED_NODE_ITERATOR_TYPE),i=[],s;for(;(s=n.iterateNext())&&(i.push(s),!(r&&i.length===r)););for(let h=0;h(r.Descendent=">>>",r.Child=">>>>",r))(H||{}),V=t=>"querySelectorAll"in t,M=class{#e;#r=[];#o=void 0;elements;constructor(e,r){this.elements=[e],this.#e=r,this.#t()}async run(){if(typeof this.#o=="string")switch(this.#o.trimStart()){case":scope":this.#t();break}for(;this.#o!==void 0;this.#t()){let e=this.#o;typeof e=="string"?e[0]&&ue.test(e[0])?this.elements=a.flatMap(this.elements,async function*(r){V(r)&&(yield*r.querySelectorAll(e))}):this.elements=a.flatMap(this.elements,async function*(r){if(!r.parentElement){if(!V(r))return;yield*r.querySelectorAll(e);return}let o=0;for(let n of r.parentElement.children)if(++o,n===r)break;yield*r.parentElement.querySelectorAll(`:scope>:nth-child(${o})${e}`)}):this.elements=a.flatMap(this.elements,async function*(r){switch(e.name){case"text":yield*m(r,e.value);break;case"xpath":yield*q(r,e.value);break;case"aria":yield*b(r,e.value);break;default:let o=P.get(e.name);if(!o)throw new Error(`Unknown selector type: ${e.name}`);yield*o.querySelectorAll(r,e.value)}})}}#t(){if(this.#r.length!==0){this.#o=this.#r.shift();return}if(this.#e.length===0){this.#o=void 0;return}let e=this.#e.shift();switch(e){case">>>>":{this.elements=a.flatMap(this.elements,T),this.#t();break}case">>>":{this.elements=a.flatMap(this.elements,O),this.#t();break}default:this.#r=e,this.#t();break}}},D=class{#e=new WeakMap;calculate(e,r=[]){if(e===null)return r;e instanceof ShadowRoot&&(e=e.host);let o=this.#e.get(e);if(o)return[...o,...r];let n=0;for(let s=e.previousSibling;s;s=s.previousSibling)++n;let i=this.calculate(e.parentNode,[n]);return this.#e.set(e,i),[...i,...r]}},U=(t,e)=>{if(t.length+e.length===0)return 0;let[r=-1,...o]=t,[n=-1,...i]=e;return r===n?U(o,i):r[o,r.calculate(o)]).sort(([,o],[,n])=>U(o,n)).map(([o])=>o)},$=function(t,e){let r=JSON.parse(e);if(r.some(o=>{let n=0;return o.some(i=>(typeof i=="string"?++n:n=0,n>1))}))throw new Error("Multiple deep combinators found in sequence.");return de(a.flatMap(r,o=>{let n=new M(t,o);return n.run(),n.elements}))},fe=async function(t,e){for await(let r of $(t,e))return r;return null};var me=Object.freeze({...x,...A,...R,..._,...C,...k,...Q,...E,Deferred:c,createFunction:F,createTextContent:d,IntervalPoller:S,isSuitableNodeForTextMatching:f,MutationPoller:y,RAFPoller:w}),he=me;\n'; + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/ScriptInjector.js +var ScriptInjector = class { + #updated = false; + #amendments = /* @__PURE__ */ new Set(); + // Appends a statement of the form `(PuppeteerUtil) => {...}`. + append(statement) { + this.#update(() => { + this.#amendments.add(statement); + }); + } + pop(statement) { + this.#update(() => { + this.#amendments.delete(statement); + }); + } + inject(inject, force = false) { + if (this.#updated || force) { + inject(this.#get()); + } + this.#updated = false; + } + #update(callback) { + callback(); + this.#updated = true; + } + #get() { + return `(() => { + const module = {}; + ${source} + ${[...this.#amendments].map((statement) => { + return `(${statement})(module.exports.default);`; + }).join("")} + return module.exports.default; + })()`; + } +}; +var scriptInjector = new ScriptInjector(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/util/decorators.js +init_cjs_shim(); +var __addDisposableResource3 = function(env, value, async2) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async2) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async2) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env.stack.push({ value, dispose, async: async2 }); + } else if (async2) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources3 = function(SuppressedError2) { + return function(env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) + throw env.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var instances = /* @__PURE__ */ new WeakSet(); +function moveable(Class, _) { + let hasDispose = false; + if (Class.prototype[disposeSymbol]) { + const dispose = Class.prototype[disposeSymbol]; + Class.prototype[disposeSymbol] = function() { + if (instances.has(this)) { + instances.delete(this); + return; + } + return dispose.call(this); + }; + hasDispose = true; + } + if (Class.prototype[asyncDisposeSymbol]) { + const asyncDispose = Class.prototype[asyncDisposeSymbol]; + Class.prototype[asyncDisposeSymbol] = function() { + if (instances.has(this)) { + instances.delete(this); + return; + } + return asyncDispose.call(this); + }; + hasDispose = true; + } + if (hasDispose) { + Class.prototype.move = function() { + instances.add(this); + return this; + }; + } + return Class; +} +function throwIfDisposed(message = (value) => { + return `Attempted to use disposed ${value.constructor.name}.`; +}) { + return (target, _) => { + return function(...args) { + if (this.disposed) { + throw new Error(message(this)); + } + return target.call(this, ...args); + }; + }; +} +function inertIfDisposed(target, _) { + return function(...args) { + if (this.disposed) { + return; + } + return target.call(this, ...args); + }; +} +function invokeAtMostOnceForArguments(target, _) { + const cache = /* @__PURE__ */ new WeakMap(); + let cacheDepth = -1; + return function(...args) { + if (cacheDepth === -1) { + cacheDepth = args.length; + } + if (cacheDepth !== args.length) { + throw new Error("Memoized method was called with the wrong number of arguments"); + } + let freshArguments = false; + let cacheIterator = cache; + for (const arg of args) { + if (cacheIterator.has(arg)) { + cacheIterator = cacheIterator.get(arg); + } else { + freshArguments = true; + cacheIterator.set(arg, /* @__PURE__ */ new WeakMap()); + cacheIterator = cacheIterator.get(arg); + } + } + if (!freshArguments) { + return; + } + return target.call(this, ...args); + }; +} +function guarded(getKey = function() { + return this; +}) { + return (target, _) => { + const mutexes = /* @__PURE__ */ new WeakMap(); + return async function(...args) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const key = getKey.call(this); + let mutex = mutexes.get(key); + if (!mutex) { + mutex = new Mutex(); + mutexes.set(key, mutex); + } + const _2 = __addDisposableResource3(env_1, await mutex.acquire(), true); + return await target.call(this, ...args); + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + const result_1 = __disposeResources3(env_1); + if (result_1) + await result_1; + } + }; + }; +} +var bubbleHandlers = /* @__PURE__ */ new WeakMap(); +var bubbleInitializer = function(events) { + const handlers = bubbleHandlers.get(this) ?? /* @__PURE__ */ new Map(); + if (handlers.has(events)) { + return; + } + const handler = events !== void 0 ? (type, event) => { + if (events.includes(type)) { + this.emit(type, event); + } + } : (type, event) => { + this.emit(type, event); + }; + handlers.set(events, handler); + bubbleHandlers.set(this, handlers); +}; +function bubble(events) { + return ({ set, get }, context2) => { + context2.addInitializer(function() { + return bubbleInitializer.apply(this, [events]); + }); + return { + set(emitter) { + const handler = bubbleHandlers.get(this).get(events); + const oldEmitter = get.call(this); + if (oldEmitter !== void 0) { + oldEmitter.off("*", handler); + } + if (emitter === void 0) { + return; + } + emitter.on("*", handler); + set.call(this, emitter); + }, + init(emitter) { + if (emitter === void 0) { + return emitter; + } + bubbleInitializer.apply(this, [events]); + const handler = bubbleHandlers.get(this).get(events); + emitter.on("*", handler); + return emitter; + } + }; + }; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/api/JSHandle.js +init_cjs_shim(); +var __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 = 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 context2 = {}; + for (var p in contextIn) + context2[p] = p === "access" ? {} : contextIn[p]; + for (var p in contextIn.access) + context2.access[p] = contextIn.access[p]; + context2.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], context2); + 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 __addDisposableResource4 = function(env, value, async2) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async2) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async2) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env.stack.push({ value, dispose, async: async2 }); + } else if (async2) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources4 = function(SuppressedError2) { + return function(env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) + throw env.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var JSHandle = (() => { + let _classDecorators = [moveable]; + let _classDescriptor; + let _classExtraInitializers = []; + let _classThis; + let _instanceExtraInitializers = []; + let _getProperty_decorators; + let _getProperties_decorators; + var JSHandle2 = class { + static { + _classThis = this; + } + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0; + __esDecorate(this, null, _getProperty_decorators, { kind: "method", name: "getProperty", static: false, private: false, access: { has: (obj) => "getProperty" in obj, get: (obj) => obj.getProperty }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate(this, null, _getProperties_decorators, { kind: "method", name: "getProperties", static: false, private: false, access: { has: (obj) => "getProperties" in obj, get: (obj) => obj.getProperties }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers); + JSHandle2 = _classThis = _classDescriptor.value; + if (_metadata) + Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + __runInitializers(_classThis, _classExtraInitializers); + } + /** + * @internal + */ + constructor() { + __runInitializers(this, _instanceExtraInitializers); + } + /** + * Evaluates the given function with the current handle as its first argument. + */ + async evaluate(pageFunction, ...args) { + pageFunction = withSourcePuppeteerURLIfNone(this.evaluate.name, pageFunction); + return await this.realm.evaluate(pageFunction, this, ...args); + } + /** + * Evaluates the given function with the current handle as its first argument. + * + */ + async evaluateHandle(pageFunction, ...args) { + pageFunction = withSourcePuppeteerURLIfNone(this.evaluateHandle.name, pageFunction); + return await this.realm.evaluateHandle(pageFunction, this, ...args); + } + /** + * @internal + */ + async getProperty(propertyName) { + return await this.evaluateHandle((object, propertyName2) => { + return object[propertyName2]; + }, propertyName); + } + /** + * Gets a map of handles representing the properties of the current handle. + * + * @example + * + * ```ts + * const listHandle = await page.evaluateHandle(() => document.body.children); + * const properties = await listHandle.getProperties(); + * const children = []; + * for (const property of properties.values()) { + * const element = property.asElement(); + * if (element) { + * children.push(element); + * } + * } + * children; // holds elementHandles to all children of document.body + * ``` + */ + async getProperties() { + const propertyNames = await this.evaluate((object) => { + const enumerableProperties = []; + const descriptors = Object.getOwnPropertyDescriptors(object); + for (const propertyName in descriptors) { + if (descriptors[propertyName]?.enumerable) { + enumerableProperties.push(propertyName); + } + } + return enumerableProperties; + }); + const map2 = /* @__PURE__ */ new Map(); + const results = await Promise.all(propertyNames.map((key) => { + return this.getProperty(key); + })); + for (const [key, value] of Object.entries(propertyNames)) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const handle = __addDisposableResource4(env_1, results[key], false); + if (handle) { + map2.set(value, handle.move()); + } + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources4(env_1); + } + } + return map2; + } + /** @internal */ + [(_getProperty_decorators = [throwIfDisposed()], _getProperties_decorators = [throwIfDisposed()], disposeSymbol)]() { + return void this.dispose().catch(debugError); + } + /** @internal */ + [asyncDisposeSymbol]() { + return this.dispose(); + } + }; + return JSHandle2 = _classThis; +})(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/api/ElementHandle.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/GetQueryHandler.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/CSSQueryHandler.js +init_cjs_shim(); +var CSSQueryHandler = class extends QueryHandler { +}; +__publicField(CSSQueryHandler, "querySelector", (element, selector, { cssQuerySelector }) => { + return cssQuerySelector(element, selector); +}); +__publicField(CSSQueryHandler, "querySelectorAll", (element, selector, { cssQuerySelectorAll }) => { + return cssQuerySelectorAll(element, selector); +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/CustomQueryHandler.js +init_cjs_shim(); +var CustomQueryHandlerRegistry = class { + #handlers = /* @__PURE__ */ new Map(); + get(name) { + const handler = this.#handlers.get(name); + return handler ? handler[1] : void 0; + } + /** + * Registers a {@link CustomQueryHandler | custom query handler}. + * + * @remarks + * After registration, the handler can be used everywhere where a selector is + * expected by prepending the selection string with `/`. The name is + * only allowed to consist of lower- and upper case latin letters. + * + * @example + * + * ```ts + * Puppeteer.customQueryHandlers.register('lit', { … }); + * const aHandle = await page.$('lit/…'); + * ``` + * + * @param name - Name to register under. + * @param queryHandler - {@link CustomQueryHandler | Custom query handler} to + * register. + */ + register(name, handler) { + assert(!this.#handlers.has(name), `Cannot register over existing handler: ${name}`); + assert(/^[a-zA-Z]+$/.test(name), `Custom query handler names may only contain [a-zA-Z]`); + assert(handler.queryAll || handler.queryOne, `At least one query method must be implemented.`); + const Handler = class extends QueryHandler { + static querySelectorAll = interpolateFunction((node, selector, PuppeteerUtil) => { + return PuppeteerUtil.customQuerySelectors.get(PLACEHOLDER("name")).querySelectorAll(node, selector); + }, { name: JSON.stringify(name) }); + static querySelector = interpolateFunction((node, selector, PuppeteerUtil) => { + return PuppeteerUtil.customQuerySelectors.get(PLACEHOLDER("name")).querySelector(node, selector); + }, { name: JSON.stringify(name) }); + }; + const registerScript = interpolateFunction((PuppeteerUtil) => { + PuppeteerUtil.customQuerySelectors.register(PLACEHOLDER("name"), { + queryAll: PLACEHOLDER("queryAll"), + queryOne: PLACEHOLDER("queryOne") + }); + }, { + name: JSON.stringify(name), + queryAll: handler.queryAll ? stringifyFunction(handler.queryAll) : String(void 0), + queryOne: handler.queryOne ? stringifyFunction(handler.queryOne) : String(void 0) + }).toString(); + this.#handlers.set(name, [registerScript, Handler]); + scriptInjector.append(registerScript); + } + /** + * Unregisters the {@link CustomQueryHandler | custom query handler} for the + * given name. + * + * @throws `Error` if there is no handler under the given name. + */ + unregister(name) { + const handler = this.#handlers.get(name); + if (!handler) { + throw new Error(`Cannot unregister unknown handler: ${name}`); + } + scriptInjector.pop(handler[0]); + this.#handlers.delete(name); + } + /** + * Gets the names of all {@link CustomQueryHandler | custom query handlers}. + */ + names() { + return [...this.#handlers.keys()]; + } + /** + * Unregisters all custom query handlers. + */ + clear() { + for (const [registerScript] of this.#handlers) { + scriptInjector.pop(registerScript); + } + this.#handlers.clear(); + } +}; +var customQueryHandlers = new CustomQueryHandlerRegistry(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/PierceQueryHandler.js +init_cjs_shim(); +var PierceQueryHandler = class extends QueryHandler { +}; +__publicField(PierceQueryHandler, "querySelector", (element, selector, { pierceQuerySelector }) => { + return pierceQuerySelector(element, selector); +}); +__publicField(PierceQueryHandler, "querySelectorAll", (element, selector, { pierceQuerySelectorAll }) => { + return pierceQuerySelectorAll(element, selector); +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/PQueryHandler.js +init_cjs_shim(); +var PQueryHandler = class extends QueryHandler { +}; +__publicField(PQueryHandler, "querySelectorAll", (element, selector, { pQuerySelectorAll }) => { + return pQuerySelectorAll(element, selector); +}); +__publicField(PQueryHandler, "querySelector", (element, selector, { pQuerySelector }) => { + return pQuerySelector(element, selector); +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/PSelectorParser.js +init_cjs_shim(); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/third_party/parsel-js/parsel-js.js +init_cjs_shim(); +var TOKENS = { + attribute: /\[\s*(?:(?\*|[-\w\P{ASCII}]*)\|)?(?[-\w\P{ASCII}]+)\s*(?:(?\W?=)\s*(?.+?)\s*(\s(?[iIsS]))?\s*)?\]/gu, + id: /#(?[-\w\P{ASCII}]+)/gu, + class: /\.(?[-\w\P{ASCII}]+)/gu, + comma: /\s*,\s*/g, + combinator: /\s*[\s>+~]\s*/g, + "pseudo-element": /::(?[-\w\P{ASCII}]+)(?:\((?¶*)\))?/gu, + "pseudo-class": /:(?[-\w\P{ASCII}]+)(?:\((?¶*)\))?/gu, + universal: /(?:(?\*|[-\w\P{ASCII}]*)\|)?\*/gu, + type: /(?:(?\*|[-\w\P{ASCII}]*)\|)?(?[-\w\P{ASCII}]+)/gu + // this must be last +}; +var TRIM_TOKENS = /* @__PURE__ */ new Set(["combinator", "comma"]); +var getArgumentPatternByType = (type) => { + switch (type) { + case "pseudo-element": + case "pseudo-class": + return new RegExp(TOKENS[type].source.replace("(?\xB6*)", "(?.*)"), "gu"); + default: + return TOKENS[type]; + } +}; +function gobbleParens(text, offset) { + let nesting = 0; + let result = ""; + for (; offset < text.length; offset++) { + const char = text[offset]; + switch (char) { + case "(": + ++nesting; + break; + case ")": + --nesting; + break; + } + result += char; + if (nesting === 0) { + return result; + } + } + return result; +} +function tokenizeBy(text, grammar = TOKENS) { + if (!text) { + return []; + } + const tokens = [text]; + for (const [type, pattern] of Object.entries(grammar)) { + for (let i = 0; i < tokens.length; i++) { + const token = tokens[i]; + if (typeof token !== "string") { + continue; + } + pattern.lastIndex = 0; + const match = pattern.exec(token); + if (!match) { + continue; + } + const from2 = match.index - 1; + const args = []; + const content = match[0]; + const before = token.slice(0, from2 + 1); + if (before) { + args.push(before); + } + args.push({ + ...match.groups, + type, + content + }); + const after = token.slice(from2 + content.length + 1); + if (after) { + args.push(after); + } + tokens.splice(i, 1, ...args); + } + } + let offset = 0; + for (const token of tokens) { + switch (typeof token) { + case "string": + throw new Error(`Unexpected sequence ${token} found at index ${offset}`); + case "object": + offset += token.content.length; + token.pos = [offset - token.content.length, offset]; + if (TRIM_TOKENS.has(token.type)) { + token.content = token.content.trim() || " "; + } + break; + } + } + return tokens; +} +var STRING_PATTERN = /(['"])([^\\\n]+?)\1/g; +var ESCAPE_PATTERN = /\\./g; +function tokenize(selector, grammar = TOKENS) { + selector = selector.trim(); + if (selector === "") { + return []; + } + const replacements = []; + selector = selector.replace(ESCAPE_PATTERN, (value, offset) => { + replacements.push({ value, offset }); + return "\uE000".repeat(value.length); + }); + selector = selector.replace(STRING_PATTERN, (value, quote, content, offset) => { + replacements.push({ value, offset }); + return `${quote}${"\uE001".repeat(content.length)}${quote}`; + }); + { + let pos = 0; + let offset; + while ((offset = selector.indexOf("(", pos)) > -1) { + const value = gobbleParens(selector, offset); + replacements.push({ value, offset }); + selector = `${selector.substring(0, offset)}(${"\xB6".repeat(value.length - 2)})${selector.substring(offset + value.length)}`; + pos = offset + value.length; + } + } + const tokens = tokenizeBy(selector, grammar); + const changedTokens = /* @__PURE__ */ new Set(); + for (const replacement of replacements.reverse()) { + for (const token of tokens) { + const { offset, value } = replacement; + if (!(token.pos[0] <= offset && offset + value.length <= token.pos[1])) { + continue; + } + const { content } = token; + const tokenOffset = offset - token.pos[0]; + token.content = content.slice(0, tokenOffset) + value + content.slice(tokenOffset + value.length); + if (token.content !== content) { + changedTokens.add(token); + } + } + } + for (const token of changedTokens) { + const pattern = getArgumentPatternByType(token.type); + if (!pattern) { + throw new Error(`Unknown token type: ${token.type}`); + } + pattern.lastIndex = 0; + const match = pattern.exec(token.content); + if (!match) { + throw new Error(`Unable to parse content for ${token.type}: ${token.content}`); + } + Object.assign(token, match.groups); + } + return tokens; +} +function* flatten(node, parent) { + switch (node.type) { + case "list": + for (let child of node.list) { + yield* flatten(child, node); + } + break; + case "complex": + yield* flatten(node.left, node); + yield* flatten(node.right, node); + break; + case "compound": + yield* node.list.map((token) => [token, node]); + break; + default: + yield [node, parent]; + } +} +function stringify(listOrNode) { + let tokens; + if (Array.isArray(listOrNode)) { + tokens = listOrNode; + } else { + tokens = [...flatten(listOrNode)].map(([token]) => token); + } + return tokens.map((token) => token.content).join(""); +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/PSelectorParser.js +TOKENS["nesting"] = /&/g; +TOKENS["combinator"] = /\s*(>>>>?|[\s>+~])\s*/g; +var ESCAPE_REGEXP = /\\[\s\S]/g; +var unquote = (text) => { + if (text.length <= 1) { + return text; + } + if ((text[0] === '"' || text[0] === "'") && text.endsWith(text[0])) { + text = text.slice(1, -1); + } + return text.replace(ESCAPE_REGEXP, (match) => { + return match[1]; + }); +}; +function parsePSelectors(selector) { + let isPureCSS = true; + let hasAria = false; + let hasPseudoClasses = false; + const tokens = tokenize(selector); + if (tokens.length === 0) { + return [[], isPureCSS, hasPseudoClasses, false]; + } + let compoundSelector = []; + let complexSelector = [compoundSelector]; + const selectors = [complexSelector]; + const storage = []; + for (const token of tokens) { + switch (token.type) { + case "combinator": + switch (token.content) { + case ">>>": + isPureCSS = false; + if (storage.length) { + compoundSelector.push(stringify(storage)); + storage.splice(0); + } + compoundSelector = []; + complexSelector.push( + ">>>" + /* PCombinator.Descendent */ + ); + complexSelector.push(compoundSelector); + continue; + case ">>>>": + isPureCSS = false; + if (storage.length) { + compoundSelector.push(stringify(storage)); + storage.splice(0); + } + compoundSelector = []; + complexSelector.push( + ">>>>" + /* PCombinator.Child */ + ); + complexSelector.push(compoundSelector); + continue; + } + break; + case "pseudo-element": + if (!token.name.startsWith("-p-")) { + break; + } + isPureCSS = false; + if (storage.length) { + compoundSelector.push(stringify(storage)); + storage.splice(0); + } + const name = token.name.slice(3); + if (name === "aria") { + hasAria = true; + } + compoundSelector.push({ + name, + value: unquote(token.argument ?? "") + }); + continue; + case "pseudo-class": + hasPseudoClasses = true; + break; + case "comma": + if (storage.length) { + compoundSelector.push(stringify(storage)); + storage.splice(0); + } + compoundSelector = []; + complexSelector = [compoundSelector]; + selectors.push(complexSelector); + continue; + } + storage.push(token); + } + if (storage.length) { + compoundSelector.push(stringify(storage)); + } + return [selectors, isPureCSS, hasPseudoClasses, hasAria]; +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/TextQueryHandler.js +init_cjs_shim(); +var TextQueryHandler = class extends QueryHandler { +}; +__publicField(TextQueryHandler, "querySelectorAll", (element, selector, { textQuerySelectorAll }) => { + return textQuerySelectorAll(element, selector); +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/XPathQueryHandler.js +init_cjs_shim(); +var XPathQueryHandler = class extends QueryHandler { +}; +__publicField(XPathQueryHandler, "querySelectorAll", (element, selector, { xpathQuerySelectorAll }) => { + return xpathQuerySelectorAll(element, selector); +}); +__publicField(XPathQueryHandler, "querySelector", (element, selector, { xpathQuerySelectorAll }) => { + for (const result of xpathQuerySelectorAll(element, selector, 1)) { + return result; + } + return null; +}); + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/common/GetQueryHandler.js +var BUILTIN_QUERY_HANDLERS = { + aria: ARIAQueryHandler, + pierce: PierceQueryHandler, + xpath: XPathQueryHandler, + text: TextQueryHandler +}; +var QUERY_SEPARATORS = ["=", "/"]; +function getQueryHandlerAndSelector(selector) { + for (const handlerMap of [ + customQueryHandlers.names().map((name) => { + return [name, customQueryHandlers.get(name)]; + }), + Object.entries(BUILTIN_QUERY_HANDLERS) + ]) { + for (const [name, QueryHandler2] of handlerMap) { + for (const separator of QUERY_SEPARATORS) { + const prefix = `${name}${separator}`; + if (selector.startsWith(prefix)) { + selector = selector.slice(prefix.length); + return { + updatedSelector: selector, + polling: name === "aria" ? "raf" : "mutation", + QueryHandler: QueryHandler2 + }; + } + } + } + } + try { + const [pSelector, isPureCSS, hasPseudoClasses, hasAria] = parsePSelectors(selector); + if (isPureCSS) { + return { + updatedSelector: selector, + polling: hasPseudoClasses ? "raf" : "mutation", + QueryHandler: CSSQueryHandler + }; + } + return { + updatedSelector: JSON.stringify(pSelector), + polling: hasAria ? "raf" : "mutation", + QueryHandler: PQueryHandler + }; + } catch { + return { + updatedSelector: selector, + polling: "mutation", + QueryHandler: CSSQueryHandler + }; + } +} + +// ../testeranto/node_modules/puppeteer-core/lib/esm/puppeteer/api/ElementHandle.js +var __runInitializers2 = 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 __esDecorate2 = 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 context2 = {}; + for (var p in contextIn) + context2[p] = p === "access" ? {} : contextIn[p]; + for (var p in contextIn.access) + context2.access[p] = contextIn.access[p]; + context2.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], context2); + 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 __addDisposableResource5 = function(env, value, async2) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") + throw new TypeError("Object expected."); + var dispose, inner; + if (async2) { + if (!Symbol.asyncDispose) + throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) + throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async2) + inner = dispose; + } + if (typeof dispose !== "function") + throw new TypeError("Object not disposable."); + if (inner) + dispose = function() { + try { + inner.call(this); + } catch (e) { + return Promise.reject(e); + } + }; + env.stack.push({ value, dispose, async: async2 }); + } else if (async2) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources5 = function(SuppressedError2) { + return function(env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) + return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) + return s |= 2, Promise.resolve(result).then(next, function(e) { + fail(e); + return next(); + }); + } else + s |= 1; + } catch (e) { + fail(e); + } + } + if (s === 1) + return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) + throw env.error; + } + return next(); + }; +}(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var __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 }); +}; +function bindIsolatedHandle(target, _) { + return async function(...args) { + if (this.realm === this.frame.isolatedRealm()) { + return await target.call(this, ...args); + } + let adoptedThis; + if (this["isolatedHandle"]) { + adoptedThis = this["isolatedHandle"]; + } else { + this["isolatedHandle"] = adoptedThis = await this.frame.isolatedRealm().adoptHandle(this); + } + const result = await target.call(adoptedThis, ...args); + if (result === adoptedThis) { + return this; + } + if (result instanceof JSHandle) { + return await this.realm.transferHandle(result); + } + if (Array.isArray(result)) { + await Promise.all(result.map(async (item, index, result2) => { + if (item instanceof JSHandle) { + result2[index] = await this.realm.transferHandle(item); + } + })); + } + if (result instanceof Map) { + await Promise.all([...result.entries()].map(async ([key, value]) => { + if (value instanceof JSHandle) { + result.set(key, await this.realm.transferHandle(value)); + } + })); + } + return result; + }; +} +var ElementHandle = (() => { + let _classSuper = JSHandle; + let _instanceExtraInitializers = []; + let _getProperty_decorators; + let _getProperties_decorators; + let _jsonValue_decorators; + let _$_decorators; + let _$$_decorators; + let _private_$$_decorators; + let _private_$$_descriptor; + let _waitForSelector_decorators; + let _isVisible_decorators; + let _isHidden_decorators; + let _toElement_decorators; + let _clickablePoint_decorators; + let _hover_decorators; + let _click_decorators; + let _drag_decorators; + let _dragEnter_decorators; + let _dragOver_decorators; + let _drop_decorators; + let _dragAndDrop_decorators; + let _select_decorators; + let _tap_decorators; + let _touchStart_decorators; + let _touchMove_decorators; + let _touchEnd_decorators; + let _focus_decorators; + let _type_decorators; + let _press_decorators; + let _boundingBox_decorators; + let _boxModel_decorators; + let _screenshot_decorators; + let _isIntersectingViewport_decorators; + let _scrollIntoView_decorators; + return class ElementHandle2 extends _classSuper { + static { + const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0; + _getProperty_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _getProperties_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _jsonValue_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _$_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _$$_decorators = [throwIfDisposed()]; + _private_$$_decorators = [bindIsolatedHandle]; + _waitForSelector_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _isVisible_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _isHidden_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _toElement_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _clickablePoint_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _hover_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _click_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _drag_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _dragEnter_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _dragOver_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _drop_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _dragAndDrop_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _select_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _tap_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _touchStart_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _touchMove_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _touchEnd_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _focus_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _type_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _press_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _boundingBox_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _boxModel_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _screenshot_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _isIntersectingViewport_decorators = [throwIfDisposed(), bindIsolatedHandle]; + _scrollIntoView_decorators = [throwIfDisposed(), bindIsolatedHandle]; + __esDecorate2(this, null, _getProperty_decorators, { kind: "method", name: "getProperty", static: false, private: false, access: { has: (obj) => "getProperty" in obj, get: (obj) => obj.getProperty }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _getProperties_decorators, { kind: "method", name: "getProperties", static: false, private: false, access: { has: (obj) => "getProperties" in obj, get: (obj) => obj.getProperties }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _jsonValue_decorators, { kind: "method", name: "jsonValue", static: false, private: false, access: { has: (obj) => "jsonValue" in obj, get: (obj) => obj.jsonValue }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _$_decorators, { kind: "method", name: "$", static: false, private: false, access: { has: (obj) => "$" in obj, get: (obj) => obj.$ }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _$$_decorators, { kind: "method", name: "$$", static: false, private: false, access: { has: (obj) => "$$" in obj, get: (obj) => obj.$$ }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, _private_$$_descriptor = { value: __setFunctionName(async function(selector) { + return await this.#$$impl(selector); + }, "#$$") }, _private_$$_decorators, { kind: "method", name: "#$$", static: false, private: true, access: { has: (obj) => #$$ in obj, get: (obj) => obj.#$$ }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _waitForSelector_decorators, { kind: "method", name: "waitForSelector", static: false, private: false, access: { has: (obj) => "waitForSelector" in obj, get: (obj) => obj.waitForSelector }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _isVisible_decorators, { kind: "method", name: "isVisible", static: false, private: false, access: { has: (obj) => "isVisible" in obj, get: (obj) => obj.isVisible }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _isHidden_decorators, { kind: "method", name: "isHidden", static: false, private: false, access: { has: (obj) => "isHidden" in obj, get: (obj) => obj.isHidden }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _toElement_decorators, { kind: "method", name: "toElement", static: false, private: false, access: { has: (obj) => "toElement" in obj, get: (obj) => obj.toElement }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _clickablePoint_decorators, { kind: "method", name: "clickablePoint", static: false, private: false, access: { has: (obj) => "clickablePoint" in obj, get: (obj) => obj.clickablePoint }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _hover_decorators, { kind: "method", name: "hover", static: false, private: false, access: { has: (obj) => "hover" in obj, get: (obj) => obj.hover }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _click_decorators, { kind: "method", name: "click", static: false, private: false, access: { has: (obj) => "click" in obj, get: (obj) => obj.click }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _drag_decorators, { kind: "method", name: "drag", static: false, private: false, access: { has: (obj) => "drag" in obj, get: (obj) => obj.drag }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _dragEnter_decorators, { kind: "method", name: "dragEnter", static: false, private: false, access: { has: (obj) => "dragEnter" in obj, get: (obj) => obj.dragEnter }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _dragOver_decorators, { kind: "method", name: "dragOver", static: false, private: false, access: { has: (obj) => "dragOver" in obj, get: (obj) => obj.dragOver }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _drop_decorators, { kind: "method", name: "drop", static: false, private: false, access: { has: (obj) => "drop" in obj, get: (obj) => obj.drop }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _dragAndDrop_decorators, { kind: "method", name: "dragAndDrop", static: false, private: false, access: { has: (obj) => "dragAndDrop" in obj, get: (obj) => obj.dragAndDrop }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _select_decorators, { kind: "method", name: "select", static: false, private: false, access: { has: (obj) => "select" in obj, get: (obj) => obj.select }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _tap_decorators, { kind: "method", name: "tap", static: false, private: false, access: { has: (obj) => "tap" in obj, get: (obj) => obj.tap }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _touchStart_decorators, { kind: "method", name: "touchStart", static: false, private: false, access: { has: (obj) => "touchStart" in obj, get: (obj) => obj.touchStart }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _touchMove_decorators, { kind: "method", name: "touchMove", static: false, private: false, access: { has: (obj) => "touchMove" in obj, get: (obj) => obj.touchMove }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _touchEnd_decorators, { kind: "method", name: "touchEnd", static: false, private: false, access: { has: (obj) => "touchEnd" in obj, get: (obj) => obj.touchEnd }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _focus_decorators, { kind: "method", name: "focus", static: false, private: false, access: { has: (obj) => "focus" in obj, get: (obj) => obj.focus }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _type_decorators, { kind: "method", name: "type", static: false, private: false, access: { has: (obj) => "type" in obj, get: (obj) => obj.type }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _press_decorators, { kind: "method", name: "press", static: false, private: false, access: { has: (obj) => "press" in obj, get: (obj) => obj.press }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _boundingBox_decorators, { kind: "method", name: "boundingBox", static: false, private: false, access: { has: (obj) => "boundingBox" in obj, get: (obj) => obj.boundingBox }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _boxModel_decorators, { kind: "method", name: "boxModel", static: false, private: false, access: { has: (obj) => "boxModel" in obj, get: (obj) => obj.boxModel }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _screenshot_decorators, { kind: "method", name: "screenshot", static: false, private: false, access: { has: (obj) => "screenshot" in obj, get: (obj) => obj.screenshot }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _isIntersectingViewport_decorators, { kind: "method", name: "isIntersectingViewport", static: false, private: false, access: { has: (obj) => "isIntersectingViewport" in obj, get: (obj) => obj.isIntersectingViewport }, metadata: _metadata }, null, _instanceExtraInitializers); + __esDecorate2(this, null, _scrollIntoView_decorators, { kind: "method", name: "scrollIntoView", static: false, private: false, access: { has: (obj) => "scrollIntoView" in obj, get: (obj) => obj.scrollIntoView }, metadata: _metadata }, null, _instanceExtraInitializers); + if (_metadata) + Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata }); + } + /** + * @internal + * Cached isolatedHandle to prevent + * trying to adopt it multiple times + */ + isolatedHandle = __runInitializers2(this, _instanceExtraInitializers); + /** + * @internal + */ + handle; + /** + * @internal + */ + constructor(handle) { + super(); + this.handle = handle; + this[_isElementHandle] = true; + } + /** + * @internal + */ + get id() { + return this.handle.id; + } + /** + * @internal + */ + get disposed() { + return this.handle.disposed; + } + /** + * @internal + */ + async getProperty(propertyName) { + return await this.handle.getProperty(propertyName); + } + /** + * @internal + */ + async getProperties() { + return await this.handle.getProperties(); + } + /** + * @internal + */ + async evaluate(pageFunction, ...args) { + pageFunction = withSourcePuppeteerURLIfNone(this.evaluate.name, pageFunction); + return await this.handle.evaluate(pageFunction, ...args); + } + /** + * @internal + */ + async evaluateHandle(pageFunction, ...args) { + pageFunction = withSourcePuppeteerURLIfNone(this.evaluateHandle.name, pageFunction); + return await this.handle.evaluateHandle(pageFunction, ...args); + } + /** + * @internal + */ + async jsonValue() { + return await this.handle.jsonValue(); + } + /** + * @internal + */ + toString() { + return this.handle.toString(); + } + /** + * @internal + */ + remoteObject() { + return this.handle.remoteObject(); + } + /** + * @internal + */ + dispose() { + return this.handle.dispose(); + } + /** + * @internal + */ + asElement() { + return this; + } + /** + * Queries the current element for an element matching the given selector. + * + * @param selector - + * {@link https://pptr.dev/guides/page-interactions#selectors | selector} + * to query the page for. + * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | CSS selectors} + * can be passed as-is and a + * {@link https://pptr.dev/guides/page-interactions#non-css-selectors | Puppeteer-specific selector syntax} + * allows quering by + * {@link https://pptr.dev/guides/page-interactions#text-selectors--p-text | text}, + * {@link https://pptr.dev/guides/page-interactions#aria-selectors--p-aria | a11y role and name}, + * and + * {@link https://pptr.dev/guides/page-interactions#xpath-selectors--p-xpath | xpath} + * and + * {@link https://pptr.dev/guides/page-interactions#querying-elements-in-shadow-dom | combining these queries across shadow roots}. + * Alternatively, you can specify the selector type using a + * {@link https://pptr.dev/guides/page-interactions#prefixed-selector-syntax | prefix}. + * @returns A {@link ElementHandle | element handle} to the first element + * matching the given selector. Otherwise, `null`. + */ + async $(selector) { + const { updatedSelector, QueryHandler: QueryHandler2 } = getQueryHandlerAndSelector(selector); + return await QueryHandler2.queryOne(this, updatedSelector); + } + /** + * Queries the current element for all elements matching the given selector. + * + * @param selector - + * {@link https://pptr.dev/guides/page-interactions#selectors | selector} + * to query the page for. + * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | CSS selectors} + * can be passed as-is and a + * {@link https://pptr.dev/guides/page-interactions#non-css-selectors | Puppeteer-specific selector syntax} + * allows quering by + * {@link https://pptr.dev/guides/page-interactions#text-selectors--p-text | text}, + * {@link https://pptr.dev/guides/page-interactions#aria-selectors--p-aria | a11y role and name}, + * and + * {@link https://pptr.dev/guides/page-interactions#xpath-selectors--p-xpath | xpath} + * and + * {@link https://pptr.dev/guides/page-interactions#querying-elements-in-shadow-dom | combining these queries across shadow roots}. + * Alternatively, you can specify the selector type using a + * {@link https://pptr.dev/guides/page-interactions#prefixed-selector-syntax | prefix}. + * @returns An array of {@link ElementHandle | element handles} that point to + * elements matching the given selector. + */ + async $$(selector, options) { + if (options?.isolate === false) { + return await this.#$$impl(selector); + } + return await this.#$$(selector); + } + /** + * Isolates {@link ElementHandle.$$} if needed. + * + * @internal + */ + get #$$() { + return _private_$$_descriptor.value; + } + /** + * Implementation for {@link ElementHandle.$$}. + * + * @internal + */ + async #$$impl(selector) { + const { updatedSelector, QueryHandler: QueryHandler2 } = getQueryHandlerAndSelector(selector); + return await AsyncIterableUtil.collect(QueryHandler2.queryAll(this, updatedSelector)); + } + /** + * Runs the given function on the first element matching the given selector in + * the current element. + * + * If the given function returns a promise, then this method will wait till + * the promise resolves. + * + * @example + * + * ```ts + * const tweetHandle = await page.$('.tweet'); + * expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe( + * '100', + * ); + * expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe( + * '10', + * ); + * ``` + * + * @param selector - + * {@link https://pptr.dev/guides/page-interactions#selectors | selector} + * to query the page for. + * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | CSS selectors} + * can be passed as-is and a + * {@link https://pptr.dev/guides/page-interactions#non-css-selectors | Puppeteer-specific selector syntax} + * allows quering by + * {@link https://pptr.dev/guides/page-interactions#text-selectors--p-text | text}, + * {@link https://pptr.dev/guides/page-interactions#aria-selectors--p-aria | a11y role and name}, + * and + * {@link https://pptr.dev/guides/page-interactions#xpath-selectors--p-xpath | xpath} + * and + * {@link https://pptr.dev/guides/page-interactions#querying-elements-in-shadow-dom | combining these queries across shadow roots}. + * Alternatively, you can specify the selector type using a + * {@link https://pptr.dev/guides/page-interactions#prefixed-selector-syntax | prefix}. + * @param pageFunction - The function to be evaluated in this element's page's + * context. The first element matching the selector will be passed in as the + * first argument. + * @param args - Additional arguments to pass to `pageFunction`. + * @returns A promise to the result of the function. + */ + async $eval(selector, pageFunction, ...args) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + pageFunction = withSourcePuppeteerURLIfNone(this.$eval.name, pageFunction); + const elementHandle = __addDisposableResource5(env_1, await this.$(selector), false); + if (!elementHandle) { + throw new Error(`Error: failed to find element matching selector "${selector}"`); + } + return await elementHandle.evaluate(pageFunction, ...args); + } catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } finally { + __disposeResources5(env_1); + } + } + /** + * Runs the given function on an array of elements matching the given selector + * in the current element. + * + * If the given function returns a promise, then this method will wait till + * the promise resolves. + * + * @example + * HTML: + * + * ```html + *
+ *
Hello!
+ *
Hi!
+ *
+ * ``` + * + * JavaScript: + * + * ```ts + * const feedHandle = await page.$('.feed'); + * expect( + * await feedHandle.$$eval('.tweet', nodes => nodes.map(n => n.innerText)), + * ).toEqual(['Hello!', 'Hi!']); + * ``` + * + * @param selector - + * {@link https://pptr.dev/guides/page-interactions#selectors | selector} + * to query the page for. + * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | CSS selectors} + * can be passed as-is and a + * {@link https://pptr.dev/guides/page-interactions#non-css-selectors | Puppeteer-specific selector syntax} + * allows quering by + * {@link https://pptr.dev/guides/page-interactions#text-selectors--p-text | text}, + * {@link https://pptr.dev/guides/page-interactions#aria-selectors--p-aria | a11y role and name}, + * and + * {@link https://pptr.dev/guides/page-interactions#xpath-selectors--p-xpath | xpath} + * and + * {@link https://pptr.dev/guides/page-interactions#querying-elements-in-shadow-dom | combining these queries across shadow roots}. + * Alternatively, you can specify the selector type using a + * {@link https://pptr.dev/guides/page-interactions#prefixed-selector-syntax | prefix}. + * @param pageFunction - The function to be evaluated in the element's page's + * context. An array of elements matching the given selector will be passed to + * the function as its first argument. + * @param args - Additional arguments to pass to `pageFunction`. + * @returns A promise to the result of the function. + */ + async $$eval(selector, pageFunction, ...args) { + const env_2 = { stack: [], error: void 0, hasError: false }; + try { + pageFunction = withSourcePuppeteerURLIfNone(this.$$eval.name, pageFunction); + const results = await this.$$(selector); + const elements = __addDisposableResource5(env_2, await this.evaluateHandle((_, ...elements2) => { + return elements2; + }, ...results), false); + const [result] = await Promise.all([ + elements.evaluate(pageFunction, ...args), + ...results.map((results2) => { + return results2.dispose(); + }) + ]); + return result; + } catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } finally { + __disposeResources5(env_2); + } + } + /** + * Wait for an element matching the given selector to appear in the current + * element. + * + * Unlike {@link Frame.waitForSelector}, this method does not work across + * navigations or if the element is detached from DOM. + * + * @example + * + * ```ts + * import puppeteer from 'puppeteer'; + * + * (async () => { + * const browser = await puppeteer.launch(); + * const page = await browser.newPage(); + * let currentURL; + * page + * .mainFrame() + * .waitForSelector('img') + * .then(() => console.log('First URL with image: ' + currentURL)); + * + * for (currentURL of [ + * 'https://example.com', + * 'https://google.com', + * 'https://bbc.com', + * ]) { + * await page.goto(currentURL); + * } + * await browser.close(); + * })(); + * ``` + * + * @param selector - The selector to query and wait for. + * @param options - Options for customizing waiting behavior. + * @returns An element matching the given selector. + * @throws Throws if an element matching the given selector doesn't appear. + */ + async waitForSelector(selector, options = {}) { + const { updatedSelector, QueryHandler: QueryHandler2, polling } = getQueryHandlerAndSelector(selector); + return await QueryHandler2.waitFor(this, updatedSelector, { + polling, + ...options + }); + } + async #checkVisibility(visibility) { + return await this.evaluate(async (element, PuppeteerUtil, visibility2) => { + return Boolean(PuppeteerUtil.checkVisibility(element, visibility2)); + }, LazyArg.create((context2) => { + return context2.puppeteerUtil; + }), visibility); + } + /** + * An element is considered to be visible if all of the following is + * true: + * + * - the element has + * {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle | computed styles}. + * + * - the element has a non-empty + * {@link https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect | bounding client rect}. + * + * - the element's {@link https://developer.mozilla.org/en-US/docs/Web/CSS/visibility | visibility} + * is not `hidden` or `collapse`. + */ + async isVisible() { + return await this.#checkVisibility(true); + } + /** + * An element is considered to be hidden if at least one of the following is true: + * + * - the element has no + * {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle | computed styles}. + * + * - the element has an empty + * {@link https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect | bounding client rect}. + * + * - the element's {@link https://developer.mozilla.org/en-US/docs/Web/CSS/visibility | visibility} + * is `hidden` or `collapse`. + */ + async isHidden() { + return await this.#checkVisibility(false); + } + /** + * Converts the current handle to the given element type. + * + * @example + * + * ```ts + * const element: ElementHandle = await page.$( + * '.class-name-of-anchor', + * ); + * // DO NOT DISPOSE `element`, this will be always be the same handle. + * const anchor: ElementHandle = + * await element.toElement('a'); + * ``` + * + * @param tagName - The tag name of the desired element type. + * @throws An error if the handle does not match. **The handle will not be + * automatically disposed.** + */ + async toElement(tagName) { + const isMatchingTagName = await this.evaluate((node, tagName2) => { + return node.nodeName === tagName2.toUpperCase(); + }, tagName); + if (!isMatchingTagName) { + throw new Error(`Element is not a(n) \`${tagName}\` element`); + } + return this; + } + /** + * Returns the middle point within an element unless a specific offset is provided. + */ + async clickablePoint(offset) { + const box = await this.#clickableBox(); + if (!box) { + throw new Error("Node is either not clickable or not an Element"); + } + if (offset !== void 0) { + return { + x: box.x + offset.x, + y: box.y + offset.y + }; + } + return { + x: box.x + box.width / 2, + y: box.y + box.height / 2 + }; + } + /** + * This method scrolls element into view if needed, and then + * uses {@link Page.mouse} to hover over the center of the element. + * If the element is detached from DOM, the method throws an error. + */ + async hover() { + await this.scrollIntoViewIfNeeded(); + const { x, y } = await this.clickablePoint(); + await this.frame.page().mouse.move(x, y); + } + /** + * This method scrolls element into view if needed, and then + * uses {@link Page.mouse} to click in the center of the element. + * If the element is detached from DOM, the method throws an error. + */ + async click(options = {}) { + await this.scrollIntoViewIfNeeded(); + const { x, y } = await this.clickablePoint(options.offset); + await this.frame.page().mouse.click(x, y, options); + } + /** + * Drags an element over the given element or point. + * + * @returns DEPRECATED. When drag interception is enabled, the drag payload is + * returned. + */ + async drag(target) { + await this.scrollIntoViewIfNeeded(); + const page = this.frame.page(); + if (page.isDragInterceptionEnabled()) { + const source2 = await this.clickablePoint(); + if (target instanceof ElementHandle2) { + target = await target.clickablePoint(); + } + return await page.mouse.drag(source2, target); + } + try { + if (!page._isDragging) { + page._isDragging = true; + await this.hover(); + await page.mouse.down(); + } + if (target instanceof ElementHandle2) { + await target.hover(); + } else { + await page.mouse.move(target.x, target.y); + } + } catch (error) { + page._isDragging = false; + throw error; + } + } + /** + * @deprecated Do not use. `dragenter` will automatically be performed during dragging. + */ + async dragEnter(data = { items: [], dragOperationsMask: 1 }) { + const page = this.frame.page(); + await this.scrollIntoViewIfNeeded(); + const target = await this.clickablePoint(); + await page.mouse.dragEnter(target, data); + } + /** + * @deprecated Do not use. `dragover` will automatically be performed during dragging. + */ + async dragOver(data = { items: [], dragOperationsMask: 1 }) { + const page = this.frame.page(); + await this.scrollIntoViewIfNeeded(); + const target = await this.clickablePoint(); + await page.mouse.dragOver(target, data); + } + /** + * @internal + */ + async drop(dataOrElement = { + items: [], + dragOperationsMask: 1 + }) { + const page = this.frame.page(); + if ("items" in dataOrElement) { + await this.scrollIntoViewIfNeeded(); + const destination = await this.clickablePoint(); + await page.mouse.drop(destination, dataOrElement); + } else { + await dataOrElement.drag(this); + page._isDragging = false; + await page.mouse.up(); + } + } + /** + * @deprecated Use `ElementHandle.drop` instead. + */ + async dragAndDrop(target, options) { + const page = this.frame.page(); + assert(page.isDragInterceptionEnabled(), "Drag Interception is not enabled!"); + await this.scrollIntoViewIfNeeded(); + const startPoint = await this.clickablePoint(); + const targetPoint = await target.clickablePoint(); + await page.mouse.dragAndDrop(startPoint, targetPoint, options); + } + /** + * Triggers a `change` and `input` event once all the provided options have been + * selected. If there's no `` has the + * `multiple` attribute, all values are considered, otherwise only the first + * one is taken into account. + */ + async select(...values) { + for (const value of values) { + assert(isString(value), 'Values must be strings. Found value "' + value + '" of type "' + typeof value + '"'); + } + return await this.evaluate((element, vals) => { + const values2 = new Set(vals); + if (!(element instanceof HTMLSelectElement)) { + throw new Error("Element is not a instead of setting `selected` on