pokeedex 0.1.0 → 0.1.5

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

@@ -1,135 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ElectronApplication = exports.Electron = void 0;
-var _timeoutSettings = require("../common/timeoutSettings");
-var _browserContext = require("./browserContext");
-var _channelOwner = require("./channelOwner");
-var _clientHelper = require("./clientHelper");
-var _events = require("./events");
-var _jsHandle = require("./jsHandle");
-var _consoleMessage = require("./consoleMessage");
-var _waiter = require("./waiter");
-var _errors = require("./errors");
-let _Symbol$asyncDispose;
-/**
- * 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 Electron extends _channelOwner.ChannelOwner {
-  static from(electron) {
-    return electron._object;
-  }
-  constructor(parent, type, guid, initializer) {
-    super(parent, type, guid, initializer);
-  }
-  async launch(options = {}) {
-    const params = {
-      ...(await (0, _browserContext.prepareBrowserContextParams)(options)),
-      env: (0, _clientHelper.envObjectToArray)(options.env ? options.env : process.env),
-      tracesDir: options.tracesDir
-    };
-    const app = ElectronApplication.from((await this._channel.launch(params)).electronApplication);
-    app._context._setOptions(params, options);
-    return app;
-  }
-}
-exports.Electron = Electron;
-_Symbol$asyncDispose = Symbol.asyncDispose;
-class ElectronApplication extends _channelOwner.ChannelOwner {
-  static from(electronApplication) {
-    return electronApplication._object;
-  }
-  constructor(parent, type, guid, initializer) {
-    super(parent, type, guid, initializer);
-    this._context = void 0;
-    this._windows = new Set();
-    this._timeoutSettings = new _timeoutSettings.TimeoutSettings();
-    this._context = _browserContext.BrowserContext.from(initializer.context);
-    for (const page of this._context._pages) this._onPage(page);
-    this._context.on(_events.Events.BrowserContext.Page, page => this._onPage(page));
-    this._channel.on('close', () => {
-      this.emit(_events.Events.ElectronApplication.Close);
-    });
-    this._channel.on('console', event => this.emit(_events.Events.ElectronApplication.Console, new _consoleMessage.ConsoleMessage(event)));
-    this._setEventToSubscriptionMapping(new Map([[_events.Events.ElectronApplication.Console, 'console']]));
-  }
-  process() {
-    return this._toImpl().process();
-  }
-  _onPage(page) {
-    this._windows.add(page);
-    this.emit(_events.Events.ElectronApplication.Window, page);
-    page.once(_events.Events.Page.Close, () => this._windows.delete(page));
-  }
-  windows() {
-    // TODO: add ElectronPage class inheriting from Page.
-    return [...this._windows];
-  }
-  async firstWindow(options) {
-    if (this._windows.size) return this._windows.values().next().value;
-    return await this.waitForEvent('window', options);
-  }
-  context() {
-    return this._context;
-  }
-  async [_Symbol$asyncDispose]() {
-    await this.close();
-  }
-  async close() {
-    try {
-      await this._context.close();
-    } catch (e) {
-      if ((0, _errors.isTargetClosedError)(e)) return;
-      throw e;
-    }
-  }
-  async waitForEvent(event, optionsOrPredicate = {}) {
-    return await this._wrapApiCall(async () => {
-      const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
-      const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
-      const waiter = _waiter.Waiter.createForEvent(this, event);
-      waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
-      if (event !== _events.Events.ElectronApplication.Close) waiter.rejectOnEvent(this, _events.Events.ElectronApplication.Close, () => new _errors.TargetClosedError());
-      const result = await waiter.waitForEvent(this, event, predicate);
-      waiter.dispose();
-      return result;
-    });
-  }
-  async browserWindow(page) {
-    const result = await this._channel.browserWindow({
-      page: page._channel
-    });
-    return _jsHandle.JSHandle.from(result.handle);
-  }
-  async evaluate(pageFunction, arg) {
-    const result = await this._channel.evaluateExpression({
-      expression: String(pageFunction),
-      isFunction: typeof pageFunction === 'function',
-      arg: (0, _jsHandle.serializeArgument)(arg)
-    });
-    return (0, _jsHandle.parseResult)(result.value);
-  }
-  async evaluateHandle(pageFunction, arg) {
-    const result = await this._channel.evaluateExpressionHandle({
-      expression: String(pageFunction),
-      isFunction: typeof pageFunction === 'function',
-      arg: (0, _jsHandle.serializeArgument)(arg)
-    });
-    return _jsHandle.JSHandle.from(result.handle);
-  }
-}
-exports.ElectronApplication = ElectronApplication;

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

@@ -1,321 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ElementHandle = void 0;
-exports.convertInputFiles = convertInputFiles;
-exports.convertSelectOptionValues = convertSelectOptionValues;
-exports.determineScreenshotType = determineScreenshotType;
-var _frame = require("./frame");
-var _jsHandle = require("./jsHandle");
-var _fs = _interopRequireDefault(require("fs"));
-var _utilsBundle = require("../utilsBundle");
-var _path = _interopRequireDefault(require("path"));
-var _utils = require("../utils");
-var _fileUtils = require("../utils/fileUtils");
-var _writableStream = require("./writableStream");
-var _stream = require("stream");
-var _util = require("util");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/**
- * 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.
- */
-
-const pipelineAsync = (0, _util.promisify)(_stream.pipeline);
-class ElementHandle extends _jsHandle.JSHandle {
-  static from(handle) {
-    return handle._object;
-  }
-  static fromNullable(handle) {
-    return handle ? ElementHandle.from(handle) : null;
-  }
-  constructor(parent, type, guid, initializer) {
-    super(parent, type, guid, initializer);
-    this._elementChannel = void 0;
-    this._elementChannel = this._channel;
-  }
-  asElement() {
-    return this;
-  }
-  async ownerFrame() {
-    return _frame.Frame.fromNullable((await this._elementChannel.ownerFrame()).frame);
-  }
-  async contentFrame() {
-    return _frame.Frame.fromNullable((await this._elementChannel.contentFrame()).frame);
-  }
-  async getAttribute(name) {
-    const value = (await this._elementChannel.getAttribute({
-      name
-    })).value;
-    return value === undefined ? null : value;
-  }
-  async inputValue() {
-    return (await this._elementChannel.inputValue()).value;
-  }
-  async textContent() {
-    const value = (await this._elementChannel.textContent()).value;
-    return value === undefined ? null : value;
-  }
-  async innerText() {
-    return (await this._elementChannel.innerText()).value;
-  }
-  async innerHTML() {
-    return (await this._elementChannel.innerHTML()).value;
-  }
-  async isChecked() {
-    return (await this._elementChannel.isChecked()).value;
-  }
-  async isDisabled() {
-    return (await this._elementChannel.isDisabled()).value;
-  }
-  async isEditable() {
-    return (await this._elementChannel.isEditable()).value;
-  }
-  async isEnabled() {
-    return (await this._elementChannel.isEnabled()).value;
-  }
-  async isHidden() {
-    return (await this._elementChannel.isHidden()).value;
-  }
-  async isVisible() {
-    return (await this._elementChannel.isVisible()).value;
-  }
-  async dispatchEvent(type, eventInit = {}) {
-    await this._elementChannel.dispatchEvent({
-      type,
-      eventInit: (0, _jsHandle.serializeArgument)(eventInit)
-    });
-  }
-  async scrollIntoViewIfNeeded(options = {}) {
-    await this._elementChannel.scrollIntoViewIfNeeded(options);
-  }
-  async hover(options = {}) {
-    await this._elementChannel.hover(options);
-  }
-  async click(options = {}) {
-    return await this._elementChannel.click(options);
-  }
-  async dblclick(options = {}) {
-    return await this._elementChannel.dblclick(options);
-  }
-  async tap(options = {}) {
-    return await this._elementChannel.tap(options);
-  }
-  async selectOption(values, options = {}) {
-    const result = await this._elementChannel.selectOption({
-      ...convertSelectOptionValues(values),
-      ...options
-    });
-    return result.values;
-  }
-  async fill(value, options = {}) {
-    return await this._elementChannel.fill({
-      value,
-      ...options
-    });
-  }
-  async selectText(options = {}) {
-    await this._elementChannel.selectText(options);
-  }
-  async setInputFiles(files, options = {}) {
-    const frame = await this.ownerFrame();
-    if (!frame) throw new Error('Cannot set input files to detached element');
-    const converted = await convertInputFiles(files, frame.page().context());
-    await this._elementChannel.setInputFiles({
-      ...converted,
-      ...options
-    });
-  }
-  async focus() {
-    await this._elementChannel.focus();
-  }
-  async type(text, options = {}) {
-    await this._elementChannel.type({
-      text,
-      ...options
-    });
-  }
-  async press(key, options = {}) {
-    await this._elementChannel.press({
-      key,
-      ...options
-    });
-  }
-  async check(options = {}) {
-    return await this._elementChannel.check(options);
-  }
-  async uncheck(options = {}) {
-    return await this._elementChannel.uncheck(options);
-  }
-  async setChecked(checked, options) {
-    if (checked) await this.check(options);else await this.uncheck(options);
-  }
-  async boundingBox() {
-    const value = (await this._elementChannel.boundingBox()).value;
-    return value === undefined ? null : value;
-  }
-  async screenshot(options = {}) {
-    const copy = {
-      ...options,
-      mask: undefined
-    };
-    if (!copy.type) copy.type = determineScreenshotType(options);
-    if (options.mask) {
-      copy.mask = options.mask.map(locator => ({
-        frame: locator._frame._channel,
-        selector: locator._selector
-      }));
-    }
-    const result = await this._elementChannel.screenshot(copy);
-    if (options.path) {
-      await (0, _fileUtils.mkdirIfNeeded)(options.path);
-      await _fs.default.promises.writeFile(options.path, result.binary);
-    }
-    return result.binary;
-  }
-  async $(selector) {
-    return ElementHandle.fromNullable((await this._elementChannel.querySelector({
-      selector
-    })).element);
-  }
-  async $$(selector) {
-    const result = await this._elementChannel.querySelectorAll({
-      selector
-    });
-    return result.elements.map(h => ElementHandle.from(h));
-  }
-  async $eval(selector, pageFunction, arg) {
-    const result = await this._elementChannel.evalOnSelector({
-      selector,
-      expression: String(pageFunction),
-      isFunction: typeof pageFunction === 'function',
-      arg: (0, _jsHandle.serializeArgument)(arg)
-    });
-    return (0, _jsHandle.parseResult)(result.value);
-  }
-  async $$eval(selector, pageFunction, arg) {
-    const result = await this._elementChannel.evalOnSelectorAll({
-      selector,
-      expression: String(pageFunction),
-      isFunction: typeof pageFunction === 'function',
-      arg: (0, _jsHandle.serializeArgument)(arg)
-    });
-    return (0, _jsHandle.parseResult)(result.value);
-  }
-  async waitForElementState(state, options = {}) {
-    return await this._elementChannel.waitForElementState({
-      state,
-      ...options
-    });
-  }
-  async waitForSelector(selector, options = {}) {
-    const result = await this._elementChannel.waitForSelector({
-      selector,
-      ...options
-    });
-    return ElementHandle.fromNullable(result.element);
-  }
-}
-exports.ElementHandle = ElementHandle;
-function convertSelectOptionValues(values) {
-  if (values === null) return {};
-  if (!Array.isArray(values)) values = [values];
-  if (!values.length) return {};
-  for (let i = 0; i < values.length; i++) (0, _utils.assert)(values[i] !== null, `options[${i}]: expected object, got null`);
-  if (values[0] instanceof ElementHandle) return {
-    elements: values.map(v => v._elementChannel)
-  };
-  if ((0, _utils.isString)(values[0])) return {
-    options: values.map(valueOrLabel => ({
-      valueOrLabel
-    }))
-  };
-  return {
-    options: values
-  };
-}
-function filePayloadExceedsSizeLimit(payloads) {
-  return payloads.reduce((size, item) => size + (item.buffer ? item.buffer.byteLength : 0), 0) >= _fileUtils.fileUploadSizeLimit;
-}
-async function resolvePathsAndDirectoryForInputFiles(items) {
-  var _localPaths2;
-  let localPaths;
-  let localDirectory;
-  for (const item of items) {
-    const stat = await _fs.default.promises.stat(item);
-    if (stat.isDirectory()) {
-      if (localDirectory) throw new Error('Multiple directories are not supported');
-      localDirectory = _path.default.resolve(item);
-    } else {
-      var _localPaths;
-      (_localPaths = localPaths) !== null && _localPaths !== void 0 ? _localPaths : localPaths = [];
-      localPaths.push(_path.default.resolve(item));
-    }
-  }
-  if ((_localPaths2 = localPaths) !== null && _localPaths2 !== void 0 && _localPaths2.length && localDirectory) throw new Error('File paths must be all files or a single directory');
-  return [localPaths, localDirectory];
-}
-async function convertInputFiles(files, context) {
-  const items = Array.isArray(files) ? files.slice() : [files];
-  if (items.some(item => typeof item === 'string')) {
-    if (!items.every(item => typeof item === 'string')) throw new Error('File paths cannot be mixed with buffers');
-    const [localPaths, localDirectory] = await resolvePathsAndDirectoryForInputFiles(items);
-    if (context._connection.isRemote()) {
-      const files = localDirectory ? (await _fs.default.promises.readdir(localDirectory, {
-        withFileTypes: true,
-        recursive: true
-      })).filter(f => f.isFile()).map(f => _path.default.join(f.path, f.name)) : localPaths;
-      const {
-        writableStreams,
-        rootDir
-      } = await context._wrapApiCall(async () => context._channel.createTempFiles({
-        rootDirName: localDirectory ? _path.default.basename(localDirectory) : undefined,
-        items: await Promise.all(files.map(async file => {
-          const lastModifiedMs = (await _fs.default.promises.stat(file)).mtimeMs;
-          return {
-            name: localDirectory ? _path.default.relative(localDirectory, file) : _path.default.basename(file),
-            lastModifiedMs
-          };
-        }))
-      }), true);
-      for (let i = 0; i < files.length; i++) {
-        const writable = _writableStream.WritableStream.from(writableStreams[i]);
-        await pipelineAsync(_fs.default.createReadStream(files[i]), writable.stream());
-      }
-      return {
-        directoryStream: rootDir,
-        streams: localDirectory ? undefined : writableStreams
-      };
-    }
-    return {
-      localPaths,
-      localDirectory
-    };
-  }
-  const payloads = items;
-  if (filePayloadExceedsSizeLimit(payloads)) throw new Error('Cannot set buffer larger than 50Mb, please write it to a file and pass its path instead.');
-  return {
-    payloads
-  };
-}
-function determineScreenshotType(options) {
-  if (options.path) {
-    const mimeType = _utilsBundle.mime.getType(options.path);
-    if (mimeType === 'image/png') return 'png';else if (mimeType === 'image/jpeg') return 'jpeg';
-    throw new Error(`path: unsupported mime type "${mimeType}"`);
-  }
-  return options.type;
-}

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

@@ -1,77 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.TimeoutError = exports.TargetClosedError = void 0;
-exports.isTargetClosedError = isTargetClosedError;
-exports.parseError = parseError;
-exports.serializeError = serializeError;
-var _utils = require("../utils");
-var _serializers = require("../protocol/serializers");
-/**
- * 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 TimeoutError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'TimeoutError';
-  }
-}
-exports.TimeoutError = TimeoutError;
-class TargetClosedError extends Error {
-  constructor(cause) {
-    super(cause || 'Target page, context or browser has been closed');
-  }
-}
-exports.TargetClosedError = TargetClosedError;
-function isTargetClosedError(error) {
-  return error instanceof TargetClosedError;
-}
-function serializeError(e) {
-  if ((0, _utils.isError)(e)) return {
-    error: {
-      message: e.message,
-      stack: e.stack,
-      name: e.name
-    }
-  };
-  return {
-    value: (0, _serializers.serializeValue)(e, value => ({
-      fallThrough: value
-    }))
-  };
-}
-function parseError(error) {
-  if (!error.error) {
-    if (error.value === undefined) throw new Error('Serialized error must have either an error or a value');
-    return (0, _serializers.parseSerializedValue)(error.value, undefined);
-  }
-  if (error.error.name === 'TimeoutError') {
-    const e = new TimeoutError(error.error.message);
-    e.stack = error.error.stack || '';
-    return e;
-  }
-  if (error.error.name === 'TargetClosedError') {
-    const e = new TargetClosedError(error.error.message);
-    e.stack = error.error.stack || '';
-    return e;
-  }
-  const e = new Error(error.error.message);
-  e.stack = error.error.stack || '';
-  e.name = error.error.name;
-  return e;
-}