pokeedex 0.1.0

data/node_modules/playwright-core/lib/client/browserType.js

@@ -0,0 +1,241 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BrowserType = void 0;
+var _browser3 = require("./browser");
+var _browserContext = require("./browserContext");
+var _channelOwner = require("./channelOwner");
+var _connection = require("./connection");
+var _events = require("./events");
+var _clientHelper = require("./clientHelper");
+var _utils = require("../utils");
+var _timeoutRunner = require("../utils/timeoutRunner");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This is here just for api generation and checking.
+
+class BrowserType extends _channelOwner.ChannelOwner {
+  constructor(...args) {
+    super(...args);
+    this._serverLauncher = void 0;
+    this._contexts = new Set();
+    this._playwright = void 0;
+    // Instrumentation.
+    this._defaultContextOptions = void 0;
+    this._defaultContextTimeout = void 0;
+    this._defaultContextNavigationTimeout = void 0;
+    this._defaultLaunchOptions = void 0;
+  }
+  static from(browserType) {
+    return browserType._object;
+  }
+  executablePath() {
+    if (!this._initializer.executablePath) throw new Error('Browser is not supported on current platform');
+    return this._initializer.executablePath;
+  }
+  name() {
+    return this._initializer.name;
+  }
+  async launch(options = {}) {
+    var _this$_defaultLaunchO;
+    (0, _utils.assert)(!options.userDataDir, 'userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead');
+    (0, _utils.assert)(!options.port, 'Cannot specify a port without launching as a server.');
+    const logger = options.logger || ((_this$_defaultLaunchO = this._defaultLaunchOptions) === null || _this$_defaultLaunchO === void 0 ? void 0 : _this$_defaultLaunchO.logger);
+    options = {
+      ...this._defaultLaunchOptions,
+      ...options
+    };
+    const launchOptions = {
+      ...options,
+      ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
+      ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
+      env: options.env ? (0, _clientHelper.envObjectToArray)(options.env) : undefined
+    };
+    return await this._wrapApiCall(async () => {
+      const browser = _browser3.Browser.from((await this._channel.launch(launchOptions)).browser);
+      this._didLaunchBrowser(browser, options, logger);
+      return browser;
+    });
+  }
+  async launchServer(options = {}) {
+    if (!this._serverLauncher) throw new Error('Launching server is not supported');
+    options = {
+      ...this._defaultLaunchOptions,
+      ...options
+    };
+    return await this._serverLauncher.launchServer(options);
+  }
+  async launchPersistentContext(userDataDir, options = {}) {
+    var _this$_defaultLaunchO2;
+    const logger = options.logger || ((_this$_defaultLaunchO2 = this._defaultLaunchOptions) === null || _this$_defaultLaunchO2 === void 0 ? void 0 : _this$_defaultLaunchO2.logger);
+    (0, _utils.assert)(!options.port, 'Cannot specify a port without launching as a server.');
+    options = {
+      ...this._defaultLaunchOptions,
+      ...this._defaultContextOptions,
+      ...options
+    };
+    const contextParams = await (0, _browserContext.prepareBrowserContextParams)(options);
+    const persistentParams = {
+      ...contextParams,
+      ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
+      ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
+      env: options.env ? (0, _clientHelper.envObjectToArray)(options.env) : undefined,
+      channel: options.channel,
+      userDataDir
+    };
+    return await this._wrapApiCall(async () => {
+      const result = await this._channel.launchPersistentContext(persistentParams);
+      const context = _browserContext.BrowserContext.from(result.context);
+      await this._didCreateContext(context, contextParams, options, logger);
+      return context;
+    });
+  }
+  async connect(optionsOrWsEndpoint, options) {
+    if (typeof optionsOrWsEndpoint === 'string') return await this._connect({
+      ...options,
+      wsEndpoint: optionsOrWsEndpoint
+    });
+    (0, _utils.assert)(optionsOrWsEndpoint.wsEndpoint, 'options.wsEndpoint is required');
+    return await this._connect(optionsOrWsEndpoint);
+  }
+  async _connect(params) {
+    const logger = params.logger;
+    return await this._wrapApiCall(async () => {
+      var _params$exposeNetwork;
+      const deadline = params.timeout ? (0, _utils.monotonicTime)() + params.timeout : 0;
+      const headers = {
+        'x-playwright-browser': this.name(),
+        ...params.headers
+      };
+      const localUtils = this._connection.localUtils();
+      const connectParams = {
+        wsEndpoint: params.wsEndpoint,
+        headers,
+        exposeNetwork: (_params$exposeNetwork = params.exposeNetwork) !== null && _params$exposeNetwork !== void 0 ? _params$exposeNetwork : params._exposeNetwork,
+        slowMo: params.slowMo,
+        timeout: params.timeout
+      };
+      if (params.__testHookRedirectPortForwarding) connectParams.socksProxyRedirectPortForTest = params.__testHookRedirectPortForwarding;
+      const {
+        pipe,
+        headers: connectHeaders
+      } = await localUtils._channel.connect(connectParams);
+      const closePipe = () => pipe.close().catch(() => {});
+      const connection = new _connection.Connection(localUtils, this._instrumentation);
+      connection.markAsRemote();
+      connection.on('close', closePipe);
+      let browser;
+      let closeError;
+      const onPipeClosed = reason => {
+        // Emulate all pages, contexts and the browser closing upon disconnect.
+        for (const context of ((_browser = browser) === null || _browser === void 0 ? void 0 : _browser.contexts()) || []) {
+          var _browser;
+          for (const page of context.pages()) page._onClose();
+          context._onClose();
+        }
+        connection.close(reason || closeError);
+        // Give a chance to any API call promises to reject upon page/context closure.
+        // This happens naturally when we receive page.onClose and browser.onClose from the server
+        // in separate tasks. However, upon pipe closure we used to dispatch them all synchronously
+        // here and promises did not have a chance to reject.
+        // The order of rejects vs closure is a part of the API contract and our test runner
+        // relies on it to attribute rejections to the right test.
+        setTimeout(() => {
+          var _browser2;
+          return (_browser2 = browser) === null || _browser2 === void 0 ? void 0 : _browser2._didClose();
+        }, 0);
+      };
+      pipe.on('closed', params => onPipeClosed(params.reason));
+      connection.onmessage = message => this._wrapApiCall(() => pipe.send({
+        message
+      }).catch(() => onPipeClosed()), /* isInternal */true);
+      pipe.on('message', ({
+        message
+      }) => {
+        try {
+          connection.dispatch(message);
+        } catch (e) {
+          closeError = String(e);
+          closePipe();
+        }
+      });
+      const result = await (0, _timeoutRunner.raceAgainstDeadline)(async () => {
+        // For tests.
+        if (params.__testHookBeforeCreateBrowser) await params.__testHookBeforeCreateBrowser();
+        const playwright = await connection.initializePlaywright();
+        if (!playwright._initializer.preLaunchedBrowser) {
+          closePipe();
+          throw new Error('Malformed endpoint. Did you use BrowserType.launchServer method?');
+        }
+        playwright._setSelectors(this._playwright.selectors);
+        browser = _browser3.Browser.from(playwright._initializer.preLaunchedBrowser);
+        this._didLaunchBrowser(browser, {}, logger);
+        browser._shouldCloseConnectionOnClose = true;
+        browser._connectHeaders = connectHeaders;
+        browser.on(_events.Events.Browser.Disconnected, () => this._wrapApiCall(() => closePipe(), /* isInternal */true));
+        return browser;
+      }, deadline);
+      if (!result.timedOut) {
+        return result.result;
+      } else {
+        closePipe();
+        throw new Error(`Timeout ${params.timeout}ms exceeded`);
+      }
+    });
+  }
+  async connectOverCDP(endpointURLOrOptions, options) {
+    if (typeof endpointURLOrOptions === 'string') return await this._connectOverCDP(endpointURLOrOptions, options);
+    const endpointURL = 'endpointURL' in endpointURLOrOptions ? endpointURLOrOptions.endpointURL : endpointURLOrOptions.wsEndpoint;
+    (0, _utils.assert)(endpointURL, 'Cannot connect over CDP without wsEndpoint.');
+    return await this.connectOverCDP(endpointURL, endpointURLOrOptions);
+  }
+  async _connectOverCDP(endpointURL, params = {}) {
+    if (this.name() !== 'chromium') throw new Error('Connecting over CDP is only supported in Chromium.');
+    const headers = params.headers ? (0, _utils.headersObjectToArray)(params.headers) : undefined;
+    const result = await this._channel.connectOverCDP({
+      endpointURL,
+      headers,
+      slowMo: params.slowMo,
+      timeout: params.timeout
+    });
+    const browser = _browser3.Browser.from(result.browser);
+    this._didLaunchBrowser(browser, {}, params.logger);
+    if (result.defaultContext) await this._didCreateContext(_browserContext.BrowserContext.from(result.defaultContext), {}, {}, params.logger);
+    return browser;
+  }
+  _didLaunchBrowser(browser, browserOptions, logger) {
+    browser._browserType = this;
+    browser._options = browserOptions;
+    browser._logger = logger;
+  }
+  async _didCreateContext(context, contextOptions, browserOptions, logger) {
+    context._logger = logger;
+    context._browserType = this;
+    this._contexts.add(context);
+    context._setOptions(contextOptions, browserOptions);
+    if (this._defaultContextTimeout !== undefined) context.setDefaultTimeout(this._defaultContextTimeout);
+    if (this._defaultContextNavigationTimeout !== undefined) context.setDefaultNavigationTimeout(this._defaultContextNavigationTimeout);
+    await this._instrumentation.runAfterCreateBrowserContext(context);
+  }
+  async _willCloseContext(context) {
+    this._contexts.delete(context);
+    await this._instrumentation.runBeforeCloseBrowserContext(context);
+  }
+}
+exports.BrowserType = BrowserType;

data/node_modules/playwright-core/lib/client/cdpSession.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CDPSession = void 0;
+var _channelOwner = require("./channelOwner");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class CDPSession extends _channelOwner.ChannelOwner {
+  static from(cdpSession) {
+    return cdpSession._object;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._channel.on('event', ({
+      method,
+      params
+    }) => {
+      this.emit(method, params);
+    });
+    this.on = super.on;
+    this.addListener = super.addListener;
+    this.off = super.removeListener;
+    this.removeListener = super.removeListener;
+    this.once = super.once;
+  }
+  async send(method, params) {
+    const result = await this._channel.send({
+      method,
+      params
+    });
+    return result.result;
+  }
+  async detach() {
+    return await this._channel.detach();
+  }
+}
+exports.CDPSession = CDPSession;

data/node_modules/playwright-core/lib/client/channelOwner.js

@@ -0,0 +1,231 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChannelOwner = void 0;
+var _eventEmitter = require("./eventEmitter");
+var _validator = require("../protocol/validator");
+var _debugLogger = require("../utils/debugLogger");
+var _stackTrace = require("../utils/stackTrace");
+var _utils = require("../utils");
+var _zones = require("../utils/zones");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class ChannelOwner extends _eventEmitter.EventEmitter {
+  constructor(parent, type, guid, initializer) {
+    super();
+    this._connection = void 0;
+    this._parent = void 0;
+    this._objects = new Map();
+    this._type = void 0;
+    this._guid = void 0;
+    this._channel = void 0;
+    this._initializer = void 0;
+    this._logger = void 0;
+    this._instrumentation = void 0;
+    this._eventToSubscriptionMapping = new Map();
+    this._wasCollected = false;
+    this.setMaxListeners(0);
+    this._connection = parent instanceof ChannelOwner ? parent._connection : parent;
+    this._type = type;
+    this._guid = guid;
+    this._parent = parent instanceof ChannelOwner ? parent : undefined;
+    this._instrumentation = this._connection._instrumentation;
+    this._connection._objects.set(guid, this);
+    if (this._parent) {
+      this._parent._objects.set(guid, this);
+      this._logger = this._parent._logger;
+    }
+    this._channel = this._createChannel(new _eventEmitter.EventEmitter());
+    this._initializer = initializer;
+  }
+  _setEventToSubscriptionMapping(mapping) {
+    this._eventToSubscriptionMapping = mapping;
+  }
+  _updateSubscription(event, enabled) {
+    const protocolEvent = this._eventToSubscriptionMapping.get(String(event));
+    if (protocolEvent) {
+      this._wrapApiCall(async () => {
+        await this._channel.updateSubscription({
+          event: protocolEvent,
+          enabled
+        });
+      }, true).catch(() => {});
+    }
+  }
+  on(event, listener) {
+    if (!this.listenerCount(event)) this._updateSubscription(event, true);
+    super.on(event, listener);
+    return this;
+  }
+  addListener(event, listener) {
+    if (!this.listenerCount(event)) this._updateSubscription(event, true);
+    super.addListener(event, listener);
+    return this;
+  }
+  prependListener(event, listener) {
+    if (!this.listenerCount(event)) this._updateSubscription(event, true);
+    super.prependListener(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    super.off(event, listener);
+    if (!this.listenerCount(event)) this._updateSubscription(event, false);
+    return this;
+  }
+  removeListener(event, listener) {
+    super.removeListener(event, listener);
+    if (!this.listenerCount(event)) this._updateSubscription(event, false);
+    return this;
+  }
+  _adopt(child) {
+    child._parent._objects.delete(child._guid);
+    this._objects.set(child._guid, child);
+    child._parent = this;
+  }
+  _dispose(reason) {
+    // Clean up from parent and connection.
+    if (this._parent) this._parent._objects.delete(this._guid);
+    this._connection._objects.delete(this._guid);
+    this._wasCollected = reason === 'gc';
+
+    // Dispose all children.
+    for (const object of [...this._objects.values()]) object._dispose(reason);
+    this._objects.clear();
+  }
+  _debugScopeState() {
+    return {
+      _guid: this._guid,
+      objects: Array.from(this._objects.values()).map(o => o._debugScopeState())
+    };
+  }
+  _createChannel(base) {
+    const channel = new Proxy(base, {
+      get: (obj, prop) => {
+        if (typeof prop === 'string') {
+          const validator = (0, _validator.maybeFindValidator)(this._type, prop, 'Params');
+          if (validator) {
+            return async params => {
+              return await this._wrapApiCall(async apiZone => {
+                const {
+                  apiName,
+                  frames,
+                  csi,
+                  callCookie,
+                  stepId
+                } = apiZone.reported ? {
+                  apiName: undefined,
+                  csi: undefined,
+                  callCookie: undefined,
+                  frames: [],
+                  stepId: undefined
+                } : apiZone;
+                apiZone.reported = true;
+                let currentStepId = stepId;
+                if (csi && apiName) {
+                  const out = {};
+                  csi.onApiCallBegin(apiName, params, frames, callCookie, out);
+                  currentStepId = out.stepId;
+                }
+                return await this._connection.sendMessageToServer(this, prop, validator(params, '', {
+                  tChannelImpl: tChannelImplToWire,
+                  binary: this._connection.rawBuffers() ? 'buffer' : 'toBase64'
+                }), apiName, frames, currentStepId);
+              });
+            };
+          }
+        }
+        return obj[prop];
+      }
+    });
+    channel._object = this;
+    return channel;
+  }
+  async _wrapApiCall(func, isInternal = false) {
+    const logger = this._logger;
+    const apiZone = _zones.zones.zoneData('apiZone');
+    if (apiZone) return await func(apiZone);
+    const stackTrace = (0, _stackTrace.captureLibraryStackTrace)();
+    let apiName = stackTrace.apiName;
+    const frames = stackTrace.frames;
+    isInternal = isInternal || this._type === 'LocalUtils';
+    if (isInternal) apiName = undefined;
+
+    // Enclosing zone could have provided the apiName and wallTime.
+    const expectZone = _zones.zones.zoneData('expectZone');
+    const stepId = expectZone === null || expectZone === void 0 ? void 0 : expectZone.stepId;
+    if (!isInternal && expectZone) apiName = expectZone.title;
+
+    // If we are coming from the expectZone, there is no need to generate a new
+    // step for the API call, since it will be generated by the expect itself.
+    const csi = isInternal || expectZone ? undefined : this._instrumentation;
+    const callCookie = {};
+    try {
+      logApiCall(logger, `=> ${apiName} started`, isInternal);
+      const apiZone = {
+        apiName,
+        frames,
+        isInternal,
+        reported: false,
+        csi,
+        callCookie,
+        stepId
+      };
+      const result = await _zones.zones.run('apiZone', apiZone, async () => await func(apiZone));
+      csi === null || csi === void 0 || csi.onApiCallEnd(callCookie);
+      logApiCall(logger, `<= ${apiName} succeeded`, isInternal);
+      return result;
+    } catch (e) {
+      const innerError = (process.env.PWDEBUGIMPL || (0, _utils.isUnderTest)()) && e.stack ? '\n<inner error>\n' + e.stack : '';
+      if (apiName && !apiName.includes('<anonymous>')) e.message = apiName + ': ' + e.message;
+      const stackFrames = '\n' + (0, _stackTrace.stringifyStackFrames)(stackTrace.frames).join('\n') + innerError;
+      if (stackFrames.trim()) e.stack = e.message + stackFrames;else e.stack = '';
+      csi === null || csi === void 0 || csi.onApiCallEnd(callCookie, e);
+      logApiCall(logger, `<= ${apiName} failed`, isInternal);
+      throw e;
+    }
+  }
+  _toImpl() {
+    var _this$_connection$toI, _this$_connection;
+    return (_this$_connection$toI = (_this$_connection = this._connection).toImpl) === null || _this$_connection$toI === void 0 ? void 0 : _this$_connection$toI.call(_this$_connection, this);
+  }
+  toJSON() {
+    // Jest's expect library tries to print objects sometimes.
+    // RPC objects can contain links to lots of other objects,
+    // which can cause jest to crash. Let's help it out
+    // by just returning the important values.
+    return {
+      _type: this._type,
+      _guid: this._guid
+    };
+  }
+}
+exports.ChannelOwner = ChannelOwner;
+function logApiCall(logger, message, isNested) {
+  if (isNested) return;
+  if (logger && logger.isEnabled('api', 'info')) logger.log('api', 'info', message, [], {
+    color: 'cyan'
+  });
+  _debugLogger.debugLogger.log('api', message);
+}
+function tChannelImplToWire(names, arg, path, context) {
+  if (arg._object instanceof ChannelOwner && (names === '*' || names.includes(arg._object._type))) return {
+    guid: arg._object._guid
+  };
+  throw new _validator.ValidationError(`${path}: expected channel ${names.toString()}`);
+}

data/node_modules/playwright-core/lib/client/clientHelper.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addSourceUrlToScript = addSourceUrlToScript;
+exports.envObjectToArray = envObjectToArray;
+exports.evaluationScript = evaluationScript;
+var _fs = _interopRequireDefault(require("fs"));
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ * Modifications copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function envObjectToArray(env) {
+  const result = [];
+  for (const name in env) {
+    if (!Object.is(env[name], undefined)) result.push({
+      name,
+      value: String(env[name])
+    });
+  }
+  return result;
+}
+async function evaluationScript(fun, arg, addSourceUrl = true) {
+  if (typeof fun === 'function') {
+    const source = fun.toString();
+    const argString = Object.is(arg, undefined) ? 'undefined' : JSON.stringify(arg);
+    return `(${source})(${argString})`;
+  }
+  if (arg !== undefined) throw new Error('Cannot evaluate a string with arguments');
+  if ((0, _utils.isString)(fun)) return fun;
+  if (fun.content !== undefined) return fun.content;
+  if (fun.path !== undefined) {
+    let source = await _fs.default.promises.readFile(fun.path, 'utf8');
+    if (addSourceUrl) source = addSourceUrlToScript(source, fun.path);
+    return source;
+  }
+  throw new Error('Either path or content property must be present');
+}
+function addSourceUrlToScript(source, path) {
+  return `${source}\n//# sourceURL=${path.replace(/\n/g, '')}`;
+}

data/node_modules/playwright-core/lib/client/clientInstrumentation.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInstrumentation = createInstrumentation;
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function createInstrumentation() {
+  const listeners = [];
+  return new Proxy({}, {
+    get: (obj, prop) => {
+      if (typeof prop !== 'string') return obj[prop];
+      if (prop === 'addListener') return listener => listeners.push(listener);
+      if (prop === 'removeListener') return listener => listeners.splice(listeners.indexOf(listener), 1);
+      if (prop === 'removeAllListeners') return () => listeners.splice(0, listeners.length);
+      if (prop.startsWith('run')) {
+        return async (...params) => {
+          for (const listener of listeners) {
+            var _prop, _ref;
+            await ((_prop = (_ref = listener)[prop]) === null || _prop === void 0 ? void 0 : _prop.call(_ref, ...params));
+          }
+        };
+      }
+      if (prop.startsWith('on')) {
+        return (...params) => {
+          for (const listener of listeners) {
+            var _prop2, _ref2;
+            (_prop2 = (_ref2 = listener)[prop]) === null || _prop2 === void 0 || _prop2.call(_ref2, ...params);
+          }
+        };
+      }
+      return obj[prop];
+    }
+  });
+}