pokeedex 0.1.0

data/node_modules/playwright-core/lib/server/bidi/third_party/bidiKeyboard.js

@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBidiKeyValue = void 0;
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * Modifications copyright (c) Microsoft Corporation.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable curly */
+
+const getBidiKeyValue = key => {
+  switch (key) {
+    case '\r':
+    case '\n':
+      key = 'Enter';
+      break;
+  }
+  // Measures the number of code points rather than UTF-16 code units.
+  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}"`);
+  }
+};
+exports.getBidiKeyValue = getBidiKeyValue;

data/node_modules/playwright-core/lib/server/bidi/third_party/bidiProtocol.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Storage = exports.Session = exports.Script = exports.Network = exports.Log = exports.Input = exports.ErrorCode = exports.BrowsingContext = exports.Browser = void 0;
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * Modifications copyright (c) Microsoft Corporation.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * THIS FILE IS AUTOGENERATED by cddlconv 0.1.5.
+ * Run `node tools/generate-bidi-types.mjs` to regenerate.
+ * @see https://github.com/w3c/webdriver-bidi/blob/master/index.bs
+ */
+/**
+ * Must be between `-9007199254740991` and `9007199254740991`, inclusive.
+ */
+/**
+ * Must be between `0` and `9007199254740991`, inclusive.
+ */
+let ErrorCode = exports.ErrorCode = /*#__PURE__*/function (ErrorCode) {
+  ErrorCode["InvalidArgument"] = "invalid argument";
+  ErrorCode["InvalidSelector"] = "invalid selector";
+  ErrorCode["InvalidSessionId"] = "invalid session id";
+  ErrorCode["MoveTargetOutOfBounds"] = "move target out of bounds";
+  ErrorCode["NoSuchAlert"] = "no such alert";
+  ErrorCode["NoSuchElement"] = "no such element";
+  ErrorCode["NoSuchFrame"] = "no such frame";
+  ErrorCode["NoSuchHandle"] = "no such handle";
+  ErrorCode["NoSuchHistoryEntry"] = "no such history entry";
+  ErrorCode["NoSuchIntercept"] = "no such intercept";
+  ErrorCode["NoSuchNode"] = "no such node";
+  ErrorCode["NoSuchRequest"] = "no such request";
+  ErrorCode["NoSuchScript"] = "no such script";
+  ErrorCode["NoSuchStoragePartition"] = "no such storage partition";
+  ErrorCode["NoSuchUserContext"] = "no such user context";
+  ErrorCode["SessionNotCreated"] = "session not created";
+  ErrorCode["UnableToCaptureScreen"] = "unable to capture screen";
+  ErrorCode["UnableToCloseBrowser"] = "unable to close browser";
+  ErrorCode["UnableToSetCookie"] = "unable to set cookie";
+  ErrorCode["UnableToSetFileInput"] = "unable to set file input";
+  ErrorCode["UnderspecifiedStoragePartition"] = "underspecified storage partition";
+  ErrorCode["UnknownCommand"] = "unknown command";
+  ErrorCode["UnknownError"] = "unknown error";
+  ErrorCode["UnsupportedOperation"] = "unsupported operation";
+  return ErrorCode;
+}({});
+let Session = exports.Session = void 0;
+(function (_Session10) {
+  let UserPromptHandlerType = /*#__PURE__*/function (UserPromptHandlerType) {
+    UserPromptHandlerType["Accept"] = "accept";
+    UserPromptHandlerType["Dismiss"] = "dismiss";
+    UserPromptHandlerType["Ignore"] = "ignore";
+    return UserPromptHandlerType;
+  }({});
+  _Session10.UserPromptHandlerType = UserPromptHandlerType;
+})(Session || (exports.Session = Session = {}));
+let Browser = exports.Browser = void 0;
+let BrowsingContext = exports.BrowsingContext = void 0;
+(function (_BrowsingContext10) {
+  let ReadinessState = /*#__PURE__*/function (ReadinessState) {
+    ReadinessState["None"] = "none";
+    ReadinessState["Interactive"] = "interactive";
+    ReadinessState["Complete"] = "complete";
+    return ReadinessState;
+  }({});
+  _BrowsingContext10.ReadinessState = ReadinessState;
+})(BrowsingContext || (exports.BrowsingContext = BrowsingContext = {}));
+(function (_BrowsingContext11) {
+  let UserPromptType = /*#__PURE__*/function (UserPromptType) {
+    UserPromptType["Alert"] = "alert";
+    UserPromptType["Beforeunload"] = "beforeunload";
+    UserPromptType["Confirm"] = "confirm";
+    UserPromptType["Prompt"] = "prompt";
+    return UserPromptType;
+  }({});
+  _BrowsingContext11.UserPromptType = UserPromptType;
+})(BrowsingContext || (exports.BrowsingContext = BrowsingContext = {}));
+(function (_BrowsingContext24) {
+  let CreateType = /*#__PURE__*/function (CreateType) {
+    CreateType["Tab"] = "tab";
+    CreateType["Window"] = "window";
+    return CreateType;
+  }({});
+  _BrowsingContext24.CreateType = CreateType;
+})(BrowsingContext || (exports.BrowsingContext = BrowsingContext = {}));
+let Network = exports.Network = void 0;
+(function (_Network6) {
+  let SameSite = /*#__PURE__*/function (SameSite) {
+    SameSite["Strict"] = "strict";
+    SameSite["Lax"] = "lax";
+    SameSite["None"] = "none";
+    return SameSite;
+  }({});
+  _Network6.SameSite = SameSite;
+})(Network || (exports.Network = Network = {}));
+(function (_Network23) {
+  let InterceptPhase = /*#__PURE__*/function (InterceptPhase) {
+    InterceptPhase["BeforeRequestSent"] = "beforeRequestSent";
+    InterceptPhase["ResponseStarted"] = "responseStarted";
+    InterceptPhase["AuthRequired"] = "authRequired";
+    return InterceptPhase;
+  }({});
+  _Network23.InterceptPhase = InterceptPhase;
+})(Network || (exports.Network = Network = {}));
+let Script = exports.Script = void 0;
+(function (_Script68) {
+  let ResultOwnership = /*#__PURE__*/function (ResultOwnership) {
+    ResultOwnership["Root"] = "root";
+    ResultOwnership["None"] = "none";
+    return ResultOwnership;
+  }({});
+  _Script68.ResultOwnership = ResultOwnership;
+})(Script || (exports.Script = Script = {}));
+let Storage = exports.Storage = void 0;
+let Log = exports.Log = void 0;
+(function (_Log7) {
+  let Level = /*#__PURE__*/function (Level) {
+    Level["Debug"] = "debug";
+    Level["Info"] = "info";
+    Level["Warn"] = "warn";
+    Level["Error"] = "error";
+    return Level;
+  }({});
+  _Log7.Level = Level;
+})(Log || (exports.Log = Log = {}));
+let Input = exports.Input = void 0;
+(function (_Input9) {
+  let PointerType = /*#__PURE__*/function (PointerType) {
+    PointerType["Mouse"] = "mouse";
+    PointerType["Pen"] = "pen";
+    PointerType["Touch"] = "touch";
+    return PointerType;
+  }({});
+  _Input9.PointerType = PointerType;
+})(Input || (exports.Input = Input = {}));

data/node_modules/playwright-core/lib/server/bidi/third_party/bidiSerializer.js

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isRegExp = exports.isPlainObject = exports.isDate = exports.BidiSerializer = void 0;
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * Modifications copyright (c) Microsoft Corporation.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable curly, indent */
+
+/**
+ * @internal
+ */
+class UnserializableError extends Error {}
+
+/**
+ * @internal
+ */
+class BidiSerializer {
+  static serialize(arg) {
+    switch (typeof arg) {
+      case 'symbol':
+      case 'function':
+        throw new UnserializableError(`Unable to serializable ${typeof arg}`);
+      case 'object':
+        return BidiSerializer._serializeObject(arg);
+      case 'undefined':
+        return {
+          type: 'undefined'
+        };
+      case 'number':
+        return BidiSerializer._serializeNumber(arg);
+      case 'bigint':
+        return {
+          type: 'bigint',
+          value: arg.toString()
+        };
+      case 'string':
+        return {
+          type: 'string',
+          value: arg
+        };
+      case 'boolean':
+        return {
+          type: 'boolean',
+          value: arg
+        };
+    }
+  }
+  static _serializeNumber(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
+    };
+  }
+  static _serializeObject(arg) {
+    if (arg === null) {
+      return {
+        type: 'null'
+      };
+    } else if (Array.isArray(arg)) {
+      const parsedArray = arg.map(subArg => {
+        return BidiSerializer.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([BidiSerializer.serialize(key), BidiSerializer.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.');
+  }
+}
+
+/**
+ * @internal
+ */
+exports.BidiSerializer = BidiSerializer;
+const isPlainObject = obj => {
+  return typeof obj === 'object' && (obj === null || obj === void 0 ? void 0 : obj.constructor) === Object;
+};
+
+/**
+ * @internal
+ */
+exports.isPlainObject = isPlainObject;
+const isRegExp = obj => {
+  return typeof obj === 'object' && (obj === null || obj === void 0 ? void 0 : obj.constructor) === RegExp;
+};
+
+/**
+ * @internal
+ */
+exports.isRegExp = isRegExp;
+const isDate = obj => {
+  return typeof obj === 'object' && (obj === null || obj === void 0 ? void 0 : obj.constructor) === Date;
+};
+exports.isDate = isDate;

data/node_modules/playwright-core/lib/server/browser.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Browser = void 0;
+var _browserContext = require("./browserContext");
+var _page = require("./page");
+var _download = require("./download");
+var _instrumentation = require("./instrumentation");
+var _artifact = require("./artifact");
+/**
+ * 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 Browser extends _instrumentation.SdkObject {
+  constructor(parent, options) {
+    super(parent, 'browser');
+    this.options = void 0;
+    this._downloads = new Map();
+    this._defaultContext = null;
+    this._startedClosing = false;
+    this._idToVideo = new Map();
+    this._contextForReuse = void 0;
+    this._closeReason = void 0;
+    this._isCollocatedWithServer = true;
+    this.attribution.browser = this;
+    this.options = options;
+    this.instrumentation.onBrowserOpen(this);
+  }
+  async newContext(metadata, options) {
+    (0, _browserContext.validateBrowserContextOptions)(options, this.options);
+    const clientCertificatesProxy = await (0, _browserContext.createClientCertificatesProxyIfNeeded)(options, this.options);
+    let context;
+    try {
+      context = await this.doCreateNewContext(options);
+    } catch (error) {
+      await (clientCertificatesProxy === null || clientCertificatesProxy === void 0 ? void 0 : clientCertificatesProxy.close());
+      throw error;
+    }
+    context._clientCertificatesProxy = clientCertificatesProxy;
+    if (options.storageState) await context.setStorageState(metadata, options.storageState);
+    return context;
+  }
+  async newContextForReuse(params, metadata) {
+    const hash = _browserContext.BrowserContext.reusableContextHash(params);
+    if (!this._contextForReuse || hash !== this._contextForReuse.hash || !this._contextForReuse.context.canResetForReuse()) {
+      if (this._contextForReuse) await this._contextForReuse.context.close({
+        reason: 'Context reused'
+      });
+      this._contextForReuse = {
+        context: await this.newContext(metadata, params),
+        hash
+      };
+      return {
+        context: this._contextForReuse.context,
+        needsReset: false
+      };
+    }
+    await this._contextForReuse.context.stopPendingOperations('Context recreated');
+    return {
+      context: this._contextForReuse.context,
+      needsReset: true
+    };
+  }
+  async stopPendingOperations(reason) {
+    var _this$_contextForReus;
+    await ((_this$_contextForReus = this._contextForReuse) === null || _this$_contextForReus === void 0 || (_this$_contextForReus = _this$_contextForReus.context) === null || _this$_contextForReus === void 0 ? void 0 : _this$_contextForReus.stopPendingOperations(reason));
+  }
+  _downloadCreated(page, uuid, url, suggestedFilename) {
+    const download = new _download.Download(page, this.options.downloadsPath || '', uuid, url, suggestedFilename);
+    this._downloads.set(uuid, download);
+  }
+  _downloadFilenameSuggested(uuid, suggestedFilename) {
+    const download = this._downloads.get(uuid);
+    if (!download) return;
+    download._filenameSuggested(suggestedFilename);
+  }
+  _downloadFinished(uuid, error) {
+    const download = this._downloads.get(uuid);
+    if (!download) return;
+    download.artifact.reportFinished(error ? new Error(error) : undefined);
+    this._downloads.delete(uuid);
+  }
+  _videoStarted(context, videoId, path, pageOrError) {
+    const artifact = new _artifact.Artifact(context, path);
+    this._idToVideo.set(videoId, {
+      context,
+      artifact
+    });
+    pageOrError.then(page => {
+      if (page instanceof _page.Page) {
+        page._video = artifact;
+        page.emitOnContext(_browserContext.BrowserContext.Events.VideoStarted, artifact);
+        page.emit(_page.Page.Events.Video, artifact);
+      }
+    });
+  }
+  _takeVideo(videoId) {
+    const video = this._idToVideo.get(videoId);
+    this._idToVideo.delete(videoId);
+    return video === null || video === void 0 ? void 0 : video.artifact;
+  }
+  _didClose() {
+    for (const context of this.contexts()) context._browserClosed();
+    if (this._defaultContext) this._defaultContext._browserClosed();
+    this.emit(Browser.Events.Disconnected);
+    this.instrumentation.onBrowserClose(this);
+  }
+  async close(options) {
+    if (!this._startedClosing) {
+      if (options.reason) this._closeReason = options.reason;
+      this._startedClosing = true;
+      await this.options.browserProcess.close();
+    }
+    if (this.isConnected()) await new Promise(x => this.once(Browser.Events.Disconnected, x));
+  }
+  async killForTests() {
+    await this.options.browserProcess.kill();
+  }
+}
+exports.Browser = Browser;
+Browser.Events = {
+  Disconnected: 'disconnected'
+};